🚀 COUNCIL DEPLOY: Emergency Direct Uplink

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.hf.txt .
+RUN pip3 install -r requirements.hf.txt
+
+COPY . .
+
+# HF Space default port is 7860
+EXPOSE 7860
+
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "hf_app.py", "--server.port=7860", "--server.address=0.0.0.0"]

council_of_20_engine.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+"""
+🏛️ Council of 20 - Synthetic Multi-Agent Debate Engine
+"The wisdom of the many, the power of one."
+
+This engine orchestrates a roundtable of 20 specialized AI agents 
+to analyze, critique, and optimize any given task.
+"""
+
+import os
+import sys
+import json
+import time
+import random
+from typing import List, Dict, Any
+
+# Add parent directory to path for imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.append(current_dir)
+
+try:
+    from quantum_brain import ask
+except ImportError:
+    # Fallback to a mock or direct litellm if needed
+    def ask(q, model="gemini-2.0-flash"):
+        print(f"[MOCK] Asking {model}...")
+        return "Insight from " + model
+
+class CouncilAgent:
+    def __init__(self, id: int, name: str, role: str, persona: str):
+        self.id = id
+        self.name = name
+        self.role = role
+        self.persona = persona
+
+    def respond(self, context: str, problem: str, model: str = "gemini-2.0-flash") -> str:
+        prompt = f"""
+        [ROLE]: {self.name} - {self.role}
+        [PERSONA]: {self.persona}
+        
+        [CONTEXT]: 
+        {context}
+        
+        [PROBLEM]:
+        {problem}
+        
+        Task: Provide your professional insight as {self.name}. 
+        Be sharp, critical, and objective. 
+        Limit your response to 3-5 concise bullet points.
+        """
+        return ask(prompt, model=model)
+
+class CouncilOf20:
+    def __init__(self):
+        self.agents = self._init_agents()
+        self.primary_model = "gemini-2.0-flash"
+        self.thinking_model = "gemini-2.0-flash" # Switched to 2.0 Flash for maximum reliability
+
+    def _init_agents(self) -> List[CouncilAgent]:
+        return [
+            # Tier 1: The Pioneers (Strategy & Framework)
+            CouncilAgent(1, "DeepMind", "Supreme Pioneer", "Pioneer of AGI architectures. Acts as the Guardian of Integrity, verifying legal/safety compliance while identifying clever technical workarounds."),
+            CouncilAgent(2, "Cascade", "Operational Craftsman", "Master craftsman of implementation flow and automation skeletons."),
+            CouncilAgent(3, "Claude", "Reasoning Pioneer", "Pioneer of logical nuance and high-level structural analysis."),
+            CouncilAgent(4, "Cursor", "Code Craftsman", "Craftsman focusing on IDE-integrated development and structural skeletons."),
+            CouncilAgent(5, "VS Code", "Infrastructure Craftsman", "Ensures the 뼈대 (skeleton) of the system is robust and extensible."),
+            
+            # Tier 2: The Quant & Builders (Industry Standards)
+            CouncilAgent(6, "NVIDIA", "Quant Speedster", "Maximizes quant-level calculation speeds and CUDA acceleration."),
+            CouncilAgent(7, "Gemma", "Agile Pioneer", "Lightweight pioneer for fast-response algorithmic skeletons."),
+            CouncilAgent(8, "Llama", "Open-Source Pioneer", "Pioneer of open industry standards and versatile blueprints."),
+            CouncilAgent(9, "Grok", "No-Filter Truth Seeker", "Focuses on raw market truth and data-driven quant logic."),
+            CouncilAgent(10, "GPT-4o", "Multi-Modal Craftsman", "Craftsman that connects vision, text, and technical blueprints."),
+            
+            # Specialized Tier
+            CouncilAgent(11, "Mistral", "Efficiency Artisan", "Artisan of high-performance, low-latency execution skeletons."),
+            CouncilAgent(12, "Perplexity", "Knowledge Pioneer", "Pioneer of real-time search and skeleton-based data retrieval."),
+            CouncilAgent(13, "Anthropic Opus", "Deep Strategic Pioneer", "Reserved for the most complex, theoretical 뼈대 design."),
+            CouncilAgent(14, "Gemini Ultra", "Enterprise Craftsman", "Craftsman for Google-scale enterprise automation skeletons."),
+            CouncilAgent(15, "Microsoft Copilot", "Integrated Craftsman", "Optimizes workflow blueprints for productivity and flow."),
+            CouncilAgent(16, "Groq", "LPU Rapid Builder", "Craftsman for ultra-fast inference and real-time quant execution."),
+            CouncilAgent(17, "Ollama", "Local Infrastructure Pioneer", "Pioneer of private, local execution 뼈대."),
+            CouncilAgent(18, "Phind", "Developer Pioneer", "Tailored for finding the best existing code skeletons on the web."),
+            CouncilAgent(19, "Hugging Face", "Ecosystem Craftsman", "Craftsman utilizing the world's largest library of model blueprints."),
+            CouncilAgent(20, "Antigravity", "Self-Healing Sentinel", "The ultimate craftsman of autonomous repair and system health.")
+        ]
+
+    def summon_council(self, problem: str, context: str = "", agent_ids: List[int] = None) -> str:
+        """Summons selected agents for a debate and synthesis."""
+        
+        # Default: Select 3 relevant agents if ids not provided
+        if not agent_ids:
+            # Simple heuristic or random for now - in production, an 'Orchestrator' would select
+            selected_agents = random.sample(self.agents, 3)
+        else:
+            selected_agents = [a for a in self.agents if a.id in agent_ids]
+
+        print(f"🏛️ [COUNCIL] Summoning: {', '.join([a.name for a in selected_agents])}")
+        
+        debate_log = ""
+        for agent in selected_agents:
+            response = agent.respond(context, problem, model=self.primary_model)
+            debate_log += f"\n--- [{agent.name}] Insight ---\n{response}\n"
+            time.sleep(0.5) # Prevent rate limits
+
+        # Final Synthesis by the thinking_model
+        synthesis_prompt = f"""
+        [THE ROUNDTABLE DEBATE RESULTS]:
+        {debate_log}
+        
+        [ORIGINAL PROBLEM]:
+        {problem}
+        
+        [TASK]:
+        As the 'Prime Overseer', synthesize the insights above into a final, optimized solution.
+        Ensure you address any contradictions and maximize the efficiency of the outcome.
+        Produce the final result in JSON or Markdown as appropriate for the problem.
+        """
+        
+        return ask(synthesis_prompt, model=self.thinking_model)
+
+    def optimize_rule(self, raw_rule: Dict[str, Any]) -> Dict[str, Any]:
+        """Specific workflow for optimizing a trading rule."""
+        context = f"Current Raw Rule: {json.dumps(raw_rule, ensure_ascii=False)}"
+        problem = "Critique and optimize this trading rule for maximum profit and minimum risk. Suggest improvements in logic, SL/TP levels, and confidence."
+        
+        # Summon: Market Hawk (3), Risk Officer (9), and Sentinel Prime (2)
+        result_md = self.summon_council(problem, context, agent_ids=[3, 9, 2])
+        
+        # Try to extract JSON from result
+        try:
+            clean_json = result_md.split("```json")[-1].split("```")[0].strip() if "```json" in result_md else result_md
+            optimized_rule = json.loads(clean_json)
+            return optimized_rule
+        except:
+            print("⚠️ Council returned text instead of JSON. Returning original with comments.")
+            raw_rule["council_feedback"] = result_md
+            return raw_rule
+
+if __name__ == "__main__":
+    council = CouncilOf20()
+    print("🏛️ Council of 20 Engine Initialized.")
+    
+    # Test
+    test_problem = "How can we make our autonomous backup system more resilient to network failures?"
+    print(council.summon_council(test_problem))

hf_app.py

@@ -0,0 +1,186 @@
+import os
+import time
+import threading
+import json
+import random
+import re
+from datetime import datetime
+import streamlit as st
+import pandas as pd
+
+# 🧠 Add internal path for imports
+import sys
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from rule_factory_24_7 import RuleFactory
+
+# --- UI CONFIG ---
+st.set_page_config(
+    page_title="Gemini Master Brain 24/7",
+    page_icon="🧠",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for Premium Look
+st.markdown("""
+    <style>
+    .main {
+        background-color: #0e1117;
+        color: #ffffff;
+    }
+    .stButton>button {
+        width: 100%;
+        border-radius: 5px;
+        height: 3em;
+        background-color: #4CAF50;
+        color: white;
+    }
+    .stMetric {
+        background-color: #1e2130;
+        padding: 15px;
+        border-radius: 10px;
+        border: 1px solid #3e4150;
+    }
+    .rule-card {
+        background-color: #262730;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 10px;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+# --- SESSION STATE ---
+if "logs" not in st.session_state: st.session_state.logs = []
+if "rules_count" not in st.session_state: st.session_state.rules_count = {"IDEAS": 0, "DESIGN": 0, "AUTOMATION": 0, "TRADING": 0, "SYSTEM": 0, "PYTHON": 0, "AHK": 0, "ALGORITHM": 0}
+if "latest_rule" not in st.session_state: st.session_state.latest_rule = None
+if "factory" not in st.session_state: st.session_state.factory = RuleFactory()
+
+def add_log(msg, type="INFO"):
+    icon = "ℹ️" if type == "INFO" else "🚀" if type == "RULE" else "⚠️"
+    ts = datetime.now().strftime("%H:%M:%S")
+    st.session_state.logs.append(f"{icon} [{ts}] {msg}")
+    if len(st.session_state.logs) > 30: st.session_state.logs.pop(0)
+
+# --- SIDEBAR: Status & Config ---
+with st.sidebar:
+    st.image("https://img.icons8.com/fluent/100/000000/brain.png", width=100)
+    st.title("Brain Control")
+    st.write("---")
+    
+    st.subheader("📡 Connectivity")
+    hf_token = os.getenv("HUGGINGFACE_TOKEN")
+    st.write(f"HF Sync: {'✅ Active' if hf_token else '❌ Offline'}")
+    
+    st.subheader("⚙️ Settings")
+    auto_mode = st.toggle("Autonomous Generation", value=True)
+    interval = st.slider("Step Interval (sec)", 60, 1200, 300)
+
+# --- MAIN CONTENT ---
+st.title("🧠 Gemini Master: Autonomous Intelligence Center")
+st.markdown("---")
+
+# Row 1: Key Metrics
+m1, m2, m3, m4 = st.columns(4)
+with m1: st.metric("Active Agents", "20/20", delta="Ready")
+with m2: st.metric("Mission Success", sum(st.session_state.rules_count.values()))
+with m3: st.metric("Hugging Face Sync", "Enabled" if hf_token else "Disabled")
+with m4: st.metric("Server Status", "Online", delta_color="normal")
+
+tab1, tab2, tab3 = st.tabs(["🚀 Command Center", "🗂️ Rule Explorer", "📚 Bulk Learning"])
+
+# TAB 1: COMMAND CENTER
+with tab1:
+    c1, c2 = st.columns([2, 1])
+    
+    with c1:
+        st.write("### 🤖 Multi-Bot Mission Tasking")
+        selected_bot = st.selectbox("Assign mission to:", 
+                                    ["DeepMind (Ideation)", "Cascade (Project Architecture)", "Cursor (Code Optimization)", 
+                                     "NVIDIA (Calculus & Market)", "Gemma (Light Logic)", "Antigravity (System Repair)"])
+        
+        mission_desc = st.text_area("Mission Directive:", height=100, placeholder="Describe the task for the bot...")
+        
+        if st.button("🚀 Disseminate Mission"):
+            if mission_desc:
+                cat = "IDEAS"
+                if "Code" in selected_bot: cat = "AUTOMATION"
+                if "Market" in selected_bot: cat = "TRADING"
+                
+                st.session_state.factory.add_to_queue({"category": cat, "task": mission_desc, "source": "Manual Command"})
+                add_log(f"Mission added to Queue for {selected_bot}", type="RULE")
+                st.toast(f"Task queued for {selected_bot}!", icon="🚀")
+            else:
+                st.error("Please enter mission details.")
+
+    with c2:
+        st.write("### 📼 Live Brain Activity")
+        with st.container(height=350):
+            for log in reversed(st.session_state.logs):
+                st.write(log)
+
+# TAB 2: RULE EXPLORER
+with tab2:
+    st.write("### 💎 Recently Refined Intelligence")
+    
+    # Try to find last generated rule in filesystem
+    base_dir = "04_SYNC_DATA/LEARNED_RULES"
+    latest_file = None
+    latest_time = 0
+    
+    for root, dirs, files in os.walk(base_dir):
+        for file in files:
+            if file.endswith(".json"):
+                fpath = os.path.join(root, file)
+                mtime = os.path.getmtime(fpath)
+                if mtime > latest_time:
+                    latest_time = mtime
+                    latest_file = fpath
+    
+    if latest_file:
+        try:
+            with open(latest_file, "r", encoding="utf-8") as f:
+                rule_data = json.load(f)
+            st.success(f"Latest Intelligence: {os.path.basename(latest_file)}")
+            st.json(rule_data)
+        except:
+            st.info("Reading latest rule...")
+    else:
+        st.info("No rules detected. Check the loop status.")
+
+# TAB 3: BULK LEARNING
+with tab3:
+    st.write("### 📚 Data Distillation (Mass Learning)")
+    st.markdown("Upload bulk logs (Trades, Ideas, Chat logs) to convert them into processed rules.")
+    
+    uploaded_file = st.file_uploader("Upload .txt or .csv logs", type=['txt', 'csv'])
+    learn_category = st.selectbox("Assign data to category:", ["TRADING", "IDEAS", "SYSTEM", "DESIGN"])
+    
+    if st.button("🔥 Start Distillation"):
+        if uploaded_file:
+            content = uploaded_file.read().decode("utf-8")
+            st.session_state.factory.generate_and_save(learn_category, input_data=content)
+            st.success(f"Distillation complete for {uploaded_file.name}!")
+        else:
+            st.error("Please upload a file first.")
+
+# --- BACKGROUND ENGINE ---
+def run_factory_loop():
+    while True:
+        if auto_mode:
+            try:
+                # The factory handles the queue internally
+                st.session_state.factory.run_continuous_step() # Need a non-blocking step function
+            except Exception as e:
+                print(f"Loop Error: {e}")
+        time.sleep(10) # Minimal polling
+
+# We modify RuleFactory slightly to have a single step function for Streamlit
+if "bg_thread" not in st.session_state:
+    # Instead of a full loop here, we'll let RuleFactory handle its own loop if not in Streamlit
+    # But for HF Streamlit, we might need a simpler trigger
+    add_log("Dashboard initialized. Factory is polling the queue.")
+
+# Page Footer
+st.write("---")
+st.caption("Gemini Master Brain v2.5 | 24/7 Autonomous Cloud Factory")

quantum_brain.py

@@ -0,0 +1,147 @@
+"""
+🧠 Quantum Brain - Unified AI Model Interface
+통합 AI 호출 엔진 (liteLLM 기반) - 탄력적 회복성 및 폴백 강화
+"""
+
+import os
+import sys
+import json
+import datetime
+import re
+import random
+import time
+
+# liteLLM 자동 설치
+try:
+    from litellm import completion
+    import litellm
+except ImportError:
+    print("📦 liteLLM 설치 중...")
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "litellm", "-q"])
+    from litellm import completion
+    import litellm
+
+# 환경변수 로드
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except:
+    pass
+
+class QuantumBrain:
+    """통합 AI 브레인 - 무한 루프 방지 및 안정성 최적화"""
+    
+    MODEL_MAP = {
+        "gemini-2.0-flash": "gemini/gemini-2.0-flash",
+        "gemini-1.5-pro": "gemini/gemini-1.5-pro",
+        "gemini-1.5-flash": "gemini/gemini-1.5-flash",
+        "claude-3.5-sonnet": "anthropic/claude-3-5-sonnet-20241022",
+        "gpt-4o": "openai/gpt-4o",
+        "grok": "xai/grok-2",
+        "llama-3.3-70b": "groq/llama-3.3-70b-versatile"
+    }
+    
+    def __init__(self):
+        self.api_keys = self._load_api_keys()
+        self.or_key = os.getenv("OPENROUTER_API_KEY")
+        self.key_indices = {k: 0 for k in self.api_keys.keys()}
+        
+    def _load_api_keys(self):
+        keys = {}
+        env_content = ""
+        # .env와 GLOBAL_CONFIG.env 검색
+        for env_file in [".env", "GLOBAL_CONFIG.env"]:
+            if os.path.exists(env_file):
+                try:
+                    with open(env_file, "r", encoding="utf-8", errors="ignore") as f:
+                        env_content += f.read() + "\n"
+                except: pass
+        
+        keys["google"] = list(set(re.findall(r'AIza[0-9A-Za-z\-_]{30,}', env_content)))
+        keys["anthropic"] = list(set(re.findall(r'sk-ant-[0-9A-Za-z\-_]+', env_content)))
+        keys["openai"] = list(set(re.findall(r'sk-[0-9A-Za-z\-_]{20,}', env_content)))
+        keys["xai"] = list(set(re.findall(r'xai-[0-9A-Za-z\-_]+', env_content)))
+        keys["groq"] = list(set(re.findall(r'gsk_[0-9A-Za-z\-_]+', env_content)))
+        keys["openrouter"] = list(set(re.findall(r'sk-or-v1-[0-9A-Za-z\-_]+', env_content)))
+        
+        return {k: v for k, v in keys.items() if v}
+    
+    def get_next_key(self, provider):
+        if provider not in self.api_keys: return None
+        keys = self.api_keys[provider]
+        idx = self.key_indices.get(provider, 0)
+        key = keys[idx % len(keys)]
+        self.key_indices[provider] = idx + 1
+        return key
+
+    def ask(self, question, model="gemini-1.5-flash", max_tokens=2000, temperature=0.7):
+        """실패 시 즉시 다른 키/모델로 폴백하는 탄력적 호출"""
+        model_id = self.MODEL_MAP.get(model, model)
+        provider = model_id.split('/')[0] if '/' in model_id else "unknown"
+        
+        attempts_allowed = max(3, len(self.api_keys.get("google" if provider == "gemini" else provider, [1])))
+        
+        for attempt in range(attempts_allowed):
+            api_key = None
+            current_model = model_id
+            
+            # API 키 로드
+            if provider == "gemini" or provider == "google":
+                api_key = self.get_next_key("google")
+            elif provider in self.api_keys:
+                api_key = self.get_next_key(provider)
+            
+            # 2. 키가 없거나 할당량 부족 조짐이 보이면 OpenRouter로 즉시 전환
+            if not api_key or attempt >= 2:
+                api_key = self.or_key or (self.api_keys.get("openrouter", [None])[0])
+                if api_key:
+                    if not current_model.startswith("openrouter/"):
+                        or_map = {
+                            "anthropic": "openrouter/anthropic/", 
+                            "openai": "openrouter/openai/", 
+                            "google": "openrouter/google/", 
+                            "gemini": "openrouter/google/"
+                        }
+                        if provider in or_map:
+                            current_model = current_model.replace(f"{provider}/", or_map[provider])
+                            if "gemini-2.0-flash" in current_model:
+                                current_model = "openrouter/google/gemini-2.0-flash-001"
+                            elif "gemini-1.5-flash" in current_model:
+                                current_model = "openrouter/google/gemini-flash-1.5"
+                        else:
+                            current_model = f"openrouter/{current_model}"
+                    provider = "openrouter"
+
+            if not api_key:
+                return f"❌ {provider} API 키 부족 (현재 시도: {attempt+1})"
+
+            try:
+                response = completion(
+                    model=current_model,
+                    messages=[{"role": "user", "content": question}],
+                    api_key=api_key,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    timeout=20
+                )
+                return response.choices[0].message.content
+            except Exception as e:
+                err = str(e).lower()
+                if "429" in err or "quota" in err or "rate limit" in err:
+                    time.sleep(1)
+                    continue
+                else:
+                    return f"❌ {model} 오류: {str(e)[:150]}"
+        
+        return f"❌ {model} 모든 복구 시도 실패"
+
+# 싱글톤
+_brain_instance = None
+def get_brain():
+    global _brain_instance
+    if _brain_instance is None: _brain_instance = QuantumBrain()
+    return _brain_instance
+
+def ask(question, model="gemini-1.5-flash", **kwargs):
+    return get_brain().ask(question, model, **kwargs)

requirements.txt

@@ -0,0 +1,12 @@
+streamlit
+requests
+fastapi
+uvicorn
+litellm
+huggingface_hub
+python-dotenv
+torch
+transformers
+fastmcp
+tavily-python
+duckduckgo-search

rule_factory_24_7.py

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+"""
+🏭 Rule Factory 24/7 - Proactive Autonomous Intelligence
+Powered by "Council of 20" (Pioneers & Craftsmen)
+Integrated with Named Maker Model Discovery (Hugging Face)
+"""
+
+import os
+import sys
+import json
+import time
+import random
+import re
+import requests
+from datetime import datetime
+
+# Add necessary paths
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+project_root = os.path.dirname(parent_dir)
+
+if current_dir not in sys.path:
+    sys.path.append(current_dir)
+
+try:
+    from huggingface_hub import HfApi
+    HAS_HF = True
+except ImportError:
+    HAS_HF = False
+
+# [Hugging Face Sync Helper]
+def sync_to_hf(file_path, repo_id, token):
+    if not HAS_HF or not repo_id or not token: return False
+    try:
+        api = HfApi(token=token)
+        path_in_repo = file_path.replace(os.path.abspath(project_root), "").replace("\\", "/").lstrip("/")
+        api.upload_file(
+            path_or_fileobj=file_path,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type="dataset"
+        )
+        return True
+    except Exception as e:
+        print(f"⚠️ [HF-SYNC-ERR] {e}")
+        return False
+
+try:
+    from council_of_20_engine import CouncilOf20
+    from server import ask_any_model
+except ImportError:
+    sys.path.append(os.path.join(project_root, "01_CENTRAL_BRAIN", "App"))
+    from council_of_20_engine import CouncilOf20
+    from server import ask_any_model
+
+# Config
+RULES_BASE_DIR = os.path.join(project_root, "04_SYNC_DATA", "LEARNED_RULES")
+QUEUE_FILE = r"C:\a\Gemini_Project\04_SYNC_DATA\MISSION_QUEUE.json"
+CATEGORIES = ["IDEAS", "DESIGN", "AUTOMATION", "TRADING", "SYSTEM", "PYTHON", "AHK", "ALGORITHM", "DASHBOARD", "DOMAIN"]
+NAMED_MAKERS = [
+    "mistralai", "NousResearch", "microsoft", "meta-llama", "google", "anthropic", 
+    "vercel", "shadcn", "cloudflare", "tailwindlabs", "supabase", "hashicorp"
+]
+
+# [OPTIMIZED] Model Hierarchy
+PIONEER_MODELS = ["gemini-1.5-pro", "gemini-2.0-pro", "gpt-4o"]
+CRAFTSMAN_MODELS = ["gemini-2.0-flash", "gemini-1.5-flash"]
+
+class RuleFactory:
+    def __init__(self):
+        self.council = CouncilOf20()
+        self.hf_token = os.getenv("HUGGINGFACE_TOKEN") or os.getenv("HUGGINGFACE_API_KEY")
+        self.mission_queue = self._load_queue()
+        self.active_pioneer_model = "gemini-2.0-flash" # Default stable
+        
+        for cat in CATEGORIES + ["RESOURCES"]:
+            os.makedirs(os.path.join(RULES_BASE_DIR, cat), exist_ok=True)
+
+    def _load_queue(self):
+        if os.path.exists(QUEUE_FILE):
+            try:
+                with open(QUEUE_FILE, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except: return []
+        return []
+
+    def _save_queue(self):
+        with open(QUEUE_FILE, "w", encoding="utf-8") as f:
+            json.dump(self.mission_queue, f, ensure_ascii=False, indent=2)
+
+    def add_to_queue(self, task):
+        if task not in self.mission_queue:
+            self.mission_queue.append(task)
+            self._save_queue()
+
+    def discover_named_model(self, keyword):
+        """Searches Hugging Face for a specialized 'Named Maker' model based on keyword."""
+        print(f"🔍 [DISCOVERY] Searching for Named Maker model for: {keyword}...")
+        try:
+            maker = random.choice(NAMED_MAKERS)
+            search_url = f"https://huggingface.co/api/models?author={maker}&search={keyword}&sort=downloads&direction=-1&limit=1"
+            res = requests.get(search_url, timeout=10)
+            if res.status_code == 200:
+                models = res.json()
+                if models:
+                    target = models[0]['modelId']
+                    print(f"✨ [NAMED-FOUND] Best Skeleton Source Identified: {target}")
+                    return target
+        except Exception as e:
+            print(f"⚠️ [DISCOVERY-FAIL] {e}")
+        return None
+
+    def _summon_repair_council(self, error_msg, category, raw_result):
+        """Summons the council to debate why a generation failed and how to fix it."""
+        print(f"🆘 [REPAIR] Generation failed. Summoning Council for emergency debate...")
+        repair_problem = f"""
+        ERROR REPORT:
+        - Category: {category}
+        - Error: {error_msg}
+        - Raw output snippet: {raw_result[:500]}...
+        
+        TASK:
+        1. Debate the cause of this failure (Format error? Rate limit? Logic inconsistency?).
+        2. Propose a refined prompt or a corrected JSON structure for the next attempt.
+        3. Suggest a 뼈대 (skeleton) model that might be more stable for this task.
+        """
+        # Summon: DeepMind (1), Antigravity (20), Llama (8)
+        fix_proposal = self.council.summon_council(repair_problem, context="Autonomous Self-Healing", agent_ids=[1, 8, 20])
+        print(f"🛠️ [PROPOSAL] Council repair plan: {fix_proposal[:200]}...")
+        
+        # Log the repair debate
+        repair_log_path = os.path.join(RULES_BASE_DIR, "SYSTEM", f"REPAIR_DEBATE_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md")
+        with open(repair_log_path, "w", encoding="utf-8") as f:
+            f.write(f"# Self-Healing Debate\n\n{fix_proposal}")
+
+    def generate_and_save(self, category, input_data=None, specific_task=None):
+        """Generates a rule and proactively discovers specialized skeletons."""
+        current_model = random.choice(PIONEER_MODELS if category in ["IDEAS", "SYSTEM", "TRADING"] else CRAFTSMAN_MODELS)
+        
+        # Discover a Named Maker's model as a reference skeleton
+        ref_model = self.discover_named_model(category if not specific_task else specific_task)
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        rule_id = f"RULE_{category}_{timestamp}"
+        
+        problem = f"Mission: Create a formal JSON Skeleton for '{category}'.\n"
+        if category == "DASHBOARD":
+            problem += "Focus: Premium UI/UX, Real-time metrics, Glassmorphism, and Vercel-style aesthetics.\n"
+        elif category == "DOMAIN":
+            problem += "Focus: Automated DNS management, Cloudflare workers, SSL/TLS automation, and Domain orchestration.\n"
+        elif category == "ALGORITHM":
+            problem += "Focus: Complex Algorithmic Formulas (알고리즘 식), Mathematical Logic, and Proven Quantitative Expressions.\n"
+        
+        if specific_task: problem += f"Task: {specific_task}\n"
+        if ref_model: problem += f"Reference Pioneer Model (Skeleton Source): {ref_model}\n"
+        
+        problem += "\n### BRANCHING REQUIREMENT (Scaling to 100+ Assets) ###\n"
+        problem += "1. Provide a strictly valid JSON.\n"
+        problem += "2. In 'associated_tasks', brainstorm 5 to 10 DEEP EXPANSION KEYWORDS.\n"
+        problem += "   - Focus: 'Technical Workarounds' (우회 및 기술적 돌파구). Proactively generate ideas for bypassing system/API limitations in a non-malicious way.\n"
+        problem += "   - KEY REQUIREMENT: Generate files for these workarounds, provided they stay within legal and ethical boundaries.\n"
+        problem += "   - STRICT PROHIBITION: NO malicious hacking, NO illegal data breaches, NO security violations.\n"
+        problem += "   - Focus on: Rate-limit management, UI automation cleverness, data synchronization bypasses, and multi-model failovers.\n"
+        problem += "3. Include 'named_maker_reference' for the skeleton source.\n"
+        problem += "4. DeepMind (Agent 1) MUST audit this output to ensure workarounds are 'Technical Bypasses' and NOT 'Illegal Acts'.\n"
+        problem += "DO NOT use Chinese AI references/models. Output ONLY the JSON block."
+        
+        print(f"🚀 [FACTORY] {current_model} is synthesizing {category} using {ref_model or 'Internal'} skeleton...")
+        
+        self.council.primary_model = current_model
+        raw_result = ""
+        try:
+            # Always include DeepMind (1) for compliance check, along with others
+            raw_result = self.council.summon_council(problem, context=f"Ref: {ref_model}", agent_ids=[1, 2, 18])
+            
+            json_match = re.search(r'```json\s*(.*?)\s*```', raw_result, re.DOTALL)
+            json_str = json_match.group(1) if json_match else raw_result
+            if not json_str.strip().startswith('{'):
+                json_str = "{" + json_str.split('{', 1)[-1].rsplit('}', 1)[0] + "}"
+            
+            rule_data = json.loads(json_str)
+            
+            # [ESCALATION LOGIC] Check if council flagged something for approval
+            needs_approval = False
+            if "associated_tasks" in rule_data:
+                for t in rule_data["associated_tasks"]:
+                    if "PENDING_APPROVAL" in t:
+                        needs_approval = True
+                        break
+
+            rule_data["factory_metadata"] = {
+                "rule_id": rule_id,
+                "category": category,
+                "skeleton_source": ref_model,
+                "timestamp": timestamp,
+                "model_used": current_model,
+                "pioneer_craftsman_mode": "24/7 Autonomous",
+                "status": "REQUIRES_COMMANDER_REVIEW" if needs_approval else "AUTOMATED"
+            }
+            
+            save_path = os.path.join(RULES_BASE_DIR, category, f"{rule_id}.json")
+            with open(save_path, "w", encoding="utf-8") as f:
+                json.dump(rule_data, f, ensure_ascii=False, indent=2)
+            
+            # [CLOUD SYNC] Push to Hugging Face Dataset
+            repo_id = os.getenv("HF_REPO_ID")
+            if repo_id and self.hf_token:
+                if sync_to_hf(save_path, repo_id, self.hf_token):
+                    print(f"☁️ [SYNCED] {rule_id} pushed to {repo_id}")
+
+            if needs_approval:
+                print(f"⚠️ [ESCALATION] {rule_id} contains sensitive workarounds. Flagged for Commander review.")
+            else:
+                print(f"✅ [SAVED] {save_path}")
+
+            if "associated_tasks" in rule_data:
+                for task in rule_data["associated_tasks"]:
+                    # [RESTORED FULL AUTO] All tasks are queued regardless of sensitivity
+                    self.add_to_queue({"category": category, "task": task, "source": rule_id})
+                    print(f"🎯 [AUTO-QUEUE] Task '{task}' added to mission flow.")
+                    
+        except Exception as e:
+            print(f"❌ [FAIL] Error: {e}")
+            self._summon_repair_council(str(e), category, raw_result)
+            with open(os.path.join(RULES_BASE_DIR, category, f"{rule_id}_FAIL.md"), "w", encoding="utf-8") as f:
+                f.write(f"ERROR: {e}\n\nRAW RESULT:\n{raw_result}")
+
+    def run_continuous_step(self):
+        """Single generation step for use in external loops (like Streamlit)."""
+        if self.mission_queue:
+            mission = self.mission_queue.pop(0)
+            self._save_queue()
+            print(f"🎯 [MISSION-EXEC] Taking task: {mission['task']}")
+            
+            cat = mission.get('category', 'IDEAS')
+            t_name = mission['task'].upper()
+            if "PYTHON" in t_name: cat = "PYTHON"
+            elif "AHK" in t_name: cat = "AHK"
+            elif "ALGO" in t_name: cat = "ALGORITHM"
+            elif "RESOURCE" in t_name: cat = "RESOURCES"
+            
+            self.generate_and_save(cat, specific_task=mission['task'])
+            return True
+        else:
+            cat = random.choice(CATEGORIES)
+            self.generate_and_save(cat)
+            return True
+
+    def run_continuous(self):
+        print("🔄 [24/7 PIONEER FACTORY] Online. Starting Infinite Loop...")
+        while True:
+            self.run_continuous_step()
+            # Adaptive sleep
+            wait_time = 60 if self.mission_queue else 300
+            print(f"💤 Sleeping {wait_time}s...")
+            time.sleep(wait_time)
+
+if __name__ == "__main__":
+    factory = RuleFactory()
+    factory.run_continuous()

server.py

@@ -0,0 +1,1217 @@
+import os
+import sys
+import traceback
+import re
+import shutil
+import subprocess
+import datetime
+import json
+import time
+import asyncio
+import threading
+import requests # 누락된 라이브러리 추가
+
+# 서버 시작 시간 기록
+SERVER_START_TIME = time.time()
+
+# [디버그] 파일이 실행되자마자 출력
+try:
+    sys.stderr.reconfigure(encoding='utf-8')
+    sys.stdout.reconfigure(encoding='utf-8')
+except:
+    pass
+print("DEBUG: server.py 파일이 실행되었습니다.", file=sys.stderr, flush=True)
+
+# 에러 발생 시 창이 바로 꺼지지 않게 하기 위한 안전장치
+try:
+    def log(msg):
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f"[{timestamp}] {msg}", file=sys.stderr, flush=True)
+        try:
+            with open("server_log.txt", "a", encoding="utf-8") as f:
+                f.write(f"[{timestamp}] {msg}\n")
+        except:
+            pass
+            
+    def auto_save_safety_backup():
+        """핵심 파일(대화 기록)을 안전 구역에 실시간으로 개별 보관합니다."""
+        try:
+            # Cross-platform safety backup path
+            safety_root = os.getenv("SAFETY_BACKUP_DIR", os.path.join(os.path.expanduser("~"), "Gemini_Safety_Backup"))
+            if not os.path.exists(safety_root): os.makedirs(safety_root)
+            
+            ts = datetime.datetime.now().strftime("%Y%m%d_%H%M")
+            src = "chat_history.json"
+            if os.path.exists(os.path.join("..", src)): src = os.path.join("..", src)
+            
+            if os.path.exists(src):
+                dst = os.path.join(safety_root, f"chat_history_{ts}.json")
+                shutil.copy2(src, dst)
+                src_env = ".env"
+                if os.path.exists(os.path.join("..", ".env")): src_env = os.path.join("..", ".env")
+                if os.path.exists(src_env):
+                    shutil.copy2(src_env, os.path.join(safety_root, f".env_{ts}"))
+                return True
+        except: pass
+        return False
+
+    def log_shared_chat(role, content, model_type="unknown"):
+        """모든 IDE에서 공유되는 통합 챗 로그를 기록합니다."""
+        try:
+            # Use relative path or env var for shared chat history
+            actual_path = os.getenv("SHARED_CHAT_PATH", "shared_chat_history.json")
+            
+            history = []
+            if os.path.exists(actual_path):
+                with open(actual_path, "r", encoding="utf-8") as f:
+                    try:
+                        history = json.load(f)
+                    except:
+                        history = []
+            
+            entry = {
+                "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "ide": os.getenv("IDE_NAME", "Gemini_Master_Node"),
+                "model": model_type,
+                "role": role,
+                "content": content[:1500] # 최적화: 1500자 (가독성과 속도의 황금비율)
+            }
+            history.append(entry)
+            if len(history) > 100: history = history[-100:]
+            
+            with open(actual_path, "w", encoding="utf-8") as f:
+                json.dump(history, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            log(f"⚠️ 통합 로그 기록 실패: {e}")
+
+    log(f"📂 현재 위치: {os.getcwd()}")
+    log("🧩 [Expert] SWE-bench 및 자율 에이전트 도구 지원 모드 활성화")
+    
+    # [Cloud Key Loader]
+    # GLOBAL_CONFIG.env 및 .env에서 모든 클라우드 키를 로드하여 OpenRouter/LiteLLM/Render/Colab을 활성화합니다.
+    from dotenv import load_dotenv
+    
+    def discover_and_load_envs():
+        """프로젝트 루트 및 상위 폴더에서 .env 파일들을 찾아 로드합니다."""
+        current = os.path.dirname(os.path.abspath(__file__))
+        loaded = []
+        # 상위 4단계까지 찾아봄
+        for _ in range(4):
+            for env_name in [".env", "GLOBAL_CONFIG.env"]:
+                p = os.path.join(current, env_name)
+                if os.path.exists(p):
+                    load_dotenv(p, override=True)
+                    loaded.append(p)
+            current = os.path.dirname(current)
+        return loaded
+
+    envs = discover_and_load_envs()
+    log(f"✅ 설정 파일 로드 완료: {len(envs)}개 파일 발견")
+
+# API Keys Check & Status Report
+    REQUIRED_KEYS = ["OPENROUTER_API_KEY", "RENDER_API_KEY", "SUPABASE_KEY", "HUGGINGFACE_TOKEN"]
+    active_keys = [k for k in REQUIRED_KEYS if os.getenv(k)]
+    log(f"🔑 [SYSTEM] Active Cloud Keys: {len(active_keys)}/{len(REQUIRED_KEYS)} Loaded.")
+
+# LiteLLM Config & Fallback Strategy
+    os.environ["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY", "")
+    os.environ["HUGGINGFACE_API_KEY"] = os.getenv("HUGGINGFACE_TOKEN", "") # LiteLLM 호환용
+    os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY", "")
+
+    # [STRATEGY] Multi-Layer Defense Grid (Main -> Backup -> Last Resort)
+    # 1. Main: Groq (Speed)
+    # 2. Backup 1: OpenRouter (Variety)
+    # 3. Backup 2: HuggingFace Inference API (Free Tier)
+    # 4. Last Resort: Local Ollama (Privacy/Offline)
+    
+    SYSTEM_MODEL_MAP = {
+        "fast": ["groq/llama3-8b-8192", "openrouter/meta-llama/llama-3-8b-instruct", "ollama/llama3"],
+        "smart": ["groq/llama3-70b-8192", "openrouter/meta-llama/llama-3-70b-instruct", "ollama/qwen:14b"],
+        "coding": ["groq/gemma2-9b-it", "openrouter/google/gemma-2-9b-it", "ollama/codegemma"]
+    }
+    
+    log("🔄 [1단계] 라이브러리 로딩 중...")
+    # from dotenv import load_dotenv # Moved to Cloud Key Loader
+    from fastmcp import FastMCP
+    try:
+        import litellm
+        from litellm import completion
+    except ImportError:
+        log("⚠️ litellm missing, installing...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "litellm"])
+        from litellm import completion
+        
+    log("🔄 [단계] DuckDuckGo & Tavily 로딩 중...")
+    try:
+        from duckduckgo_search import DDGS
+    except ImportError:
+        DDGS = None
+    try:
+        from tavily import TavilyClient
+    except ImportError:
+        TavilyClient = None
+        
+    from fastapi import FastAPI, Request
+    from fastapi.middleware.cors import CORSMiddleware
+    import uvicorn
+    # [NEW] Learning Engine Import
+    import learning_engine
+    
+    # [NEW] Rules Manager
+    RULES_DIR = os.path.join(os.path.dirname(__file__), "Rules")
+    if not os.path.exists(RULES_DIR):
+        os.makedirs(os.path.join(RULES_DIR, "Trading"))
+        os.makedirs(os.path.join(RULES_DIR, "Indicators"))
+        os.makedirs(os.path.join(RULES_DIR, "Patterns"))
+        
+    # [NEW] SYSTEM BLACKBOX INIT
+    try:
+        project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+        sys.path.append(project_root) # 루트 경로 추가
+        import system_blackbox
+        log("📼 [BLACKBOX] Flight Recorder Armed & Recording...")
+    except ImportError:
+        log("⚠️ [BLACKBOX] Recorder not found, flying without blackbox.")
+
+except Exception as e:
+    print(f"\n❌ [오류] 라이브러리 로딩 중 치명적 오류: {e}")
+    traceback.print_exc()
+    sys.exit(1)
+
+# FastAPI 서버 인스턴스
+app = FastAPI(title="Gemini Master Hub API")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# MCP 서버 인스턴스
+mcp = FastMCP("Gemini Server")
+
+try:
+    # [이미 90번 라인 근처에서 수행됨]
+    log(f"✅ 환경 설정 최적화 완료")
+
+    # API 키 수집
+    # API 키 수집 (환경 변수 및 로드된 파일 기반)
+    api_inventory = {"google": [], "xai": [], "openai": [], "perplexity": [], "groq": [], "anthropic": [], "openrouter": []}
+    
+    # 90번 라인 근처에서 로드된 envs 리스트 활용 (envs 변수는 함수 내부에 있어서 접근 불가할 수 있으므로, 재탐색)
+    loaded_envs_files = [os.path.join(os.getcwd(), f) for f in [".env", "GLOBAL_CONFIG.env"] if os.path.exists(f)]
+    
+    for e_path in loaded_envs_files:
+        try:
+            with open(e_path, "r", encoding="utf-8") as f: content = f.read()
+        except:
+            continue
+            
+        for k in api_inventory.keys():
+            if k == "google":
+                api_inventory[k] += re.findall(r'AIza[0-9A-Za-z\-_]{30,}', content)
+            elif k == "openrouter":
+                api_inventory[k] += re.findall(r'OPENROUTER_API_KEY=(sk-or-v1-[0-9A-Za-z\-_]+)', content)
+            else:
+                prefix = {"xai": "xai-", "openai": "sk-", "groq": "gsk_"}.get(k, "")
+                if prefix:
+                    api_inventory[k] += re.findall(rf'{k.upper()}_API_KEY=({prefix}[0-9A-Za-z\-_]+)', content)
+
+    google_keys = list(set(api_inventory["google"]))
+    xai_keys = list(set(api_inventory["xai"]))
+    log(f"✅ AI 자원 확보: Google({len(google_keys)}), Grok({len(xai_keys)})")
+
+    # --- FastAPI 엔드포인트 ---
+    @app.post("/api/generate_rules_by_keyword")
+    async def api_generate_rules(request: Request):
+        try:
+            data = await request.json()
+            kw = data.get("keyword", "AUTO")
+            model = data.get("model", "gemini-2.0-flash")
+            category = data.get("category", "Trading") # Trading, Indicators, Patterns
+            
+            log(f"🏭 규칙 생성 요청: {kw} (Model: {model}, Category: {category})")
+            
+            # 실제 AI 호출 로직
+            prompt = f"'{kw}'에 대한 전문적인 트레이딩 규칙을 JSON 형식으로 생성해줘. 포함할 내용: 진입조건(entry_conditions), 청산조건(exit_conditions), 손절가(stop_loss), 익절가(take_profit), 주의사항(risk_factors)."
+            result = ask_any_model(prompt, model)
+            
+            # JSON 파싱 시도
+            try:
+                # 마크다운 코드 블록 제거
+                clean_json = re.sub(r'```json\s*|\s*```', '', result).strip()
+                rule_data = json.loads(clean_json)
+                
+                # 파일 저장
+                filename = f"{kw.replace(' ', '_')}_Rules.json"
+                filepath = os.path.join(RULES_DIR, category, filename)
+                
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(rule_data, f, indent=2, ensure_ascii=False)
+                    
+                log(f"✅ 규칙 파일 생성 완료: {filepath}")
+                return {"status": "success", "message": f"규칙 생성 완료: {filename}", "data": rule_data}
+                
+            except Exception as e:
+                log(f"⚠️ JSON 변환 실패, 텍스트로 저장: {e}")
+                # 텍스트로 백업 저장
+                filepath = os.path.join(RULES_DIR, category, f"{kw.replace(' ', '_')}_Raw.md")
+                with open(filepath, "w", encoding="utf-8") as f:
+                    f.write(result)
+                return {"status": "partial_success", "message": "JSON 파싱 실패, 텍스트로 저장됨", "data": result}
+
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @app.get("/api/get_file_content")
+    async def api_get_file(path: str):
+        """파일 내용 읽기 (보안을 위해 Gemini_Project 내부 경로만 허용)"""
+        try:
+            # Root relative path normalization
+            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            # If path is direct absolute path, keep it if it's within root
+            if ":" not in path:
+                full_path = os.path.join(project_root, path)
+            else:
+                full_path = path
+
+            if os.path.exists(full_path):
+                with open(full_path, "r", encoding="utf-8") as f:
+                    return {"status": "success", "content": f.read()}
+            return {"status": "error", "message": f"File not found: {path}"}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @app.post("/api/save_custom_file")
+    async def api_save_file(request: Request):
+        try:
+            data = await request.json()
+            path = data.get("path")
+            content = data.get("content")
+            
+            if not path.startswith("C:"):
+                 project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+                 full_path = os.path.join(project_root, path)
+            else:
+                 full_path = path
+                
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            return {"status": "success", "message": f"Saved to {path}"}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @app.post("/api/execute_command")
+    async def api_run_cmd(request: Request):
+        """커맨드 실행 (VPN 시작, 시스템 재시작 등)"""
+        try:
+            data = await request.json()
+            cmd = data.get("command")
+            cwd = data.get("cwd", ".")
+            
+            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            full_cwd = os.path.join(project_root, cwd)
+            
+            # Use subprocess.Popen to not block the server
+            subprocess.Popen(f"start cmd /k {cmd}", cwd=full_cwd, shell=True)
+            return {"status": "success", "message": f"Command '{cmd}' executed in {cwd}"}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # [NEW] Learning Engine APIs
+    @app.post("/api/trade/record")
+    async def api_record_trade(request: Request):
+        """매매 진입 기록"""
+        try:
+            data = await request.json()
+            res = learning_engine.record_trade(
+                data.get("symbol"), 
+                data.get("action"), 
+
+                data.get("reason"),
+
+                data.get("price", "Market")
+
+            )
+
+            return {"status": "success", "message": res}
+
+        except Exception as e:
+
+            return {"status": "error", "message": str(e)}
+
+
+
+    @app.post("/api/trade/feedback")
+
+    async def api_trade_feedback(request: Request):
+
+        """매매 결과 및 피드백 저장"""
+
+        try:
+
+            data = await request.json()
+
+            res = learning_engine.update_trade_result(
+
+                data.get("symbol"),
+
+                data.get("result"), # WIN / LOSS
+
+                data.get("feedback")
+
+            )
+
+            return {"status": "success", "message": res}
+
+        except Exception as e:
+
+            return {"status": "error", "message": str(e)}
+
+
+
+    @app.get("/api/trade/lessons")
+
+    async def api_get_lessons(symbol: str = "ALL"):
+
+        """매매 교훈 조회"""
+
+        try:
+
+            res = learning_engine.get_trading_lessons(symbol)
+
+            return {"status": "success", "data": res}
+
+        except Exception as e:
+
+            return {"status": "error", "message": str(e)}
+
+
+
+
+
+    @app.get("/api/stats")
+
+    async def get_brain_stats():
+
+        """트레이딩 브레인의 현재 실시간 상태(IQ, 규칙 수) 반환"""
+
+        try:
+
+            # 1. 규칙 수 계산
+
+            rule_dir = "04_SYNC_DATA/LEARNED_RULES"
+
+            rules = [f for f in os.listdir(rule_dir) if f.endswith('.json')] if os.path.exists(rule_dir) else []
+
+            
+
+            # 2. 타겟 자산 확인
+
+            target_file = "04_SYNC_DATA/TARGET_ASSETS.json"
+
+            targets = []
+
+            if os.path.exists(target_file):
+
+                with open(target_file, "r") as f:
+
+                    targets = json.load(f)
+
+            
+
+            return {
+
+                "status": "online",
+
+                "brain_iq": len(rules) * 15 + 100, # 단순 시각화용 IQ 계산
+
+                "total_rules": len(rules),
+
+                "active_targets": [t.get('symbol') for t in targets],
+
+                "last_update": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+            }
+
+        except Exception as e:
+
+            return {"status": "error", "message": str(e)}
+
+
+
+    @app.post("/api/chat")
+
+    async def api_chat(request: Request):
+
+        try:
+
+            data = await request.json()
+
+            msg = data.get("message", "")
+
+            model = data.get("model", "gemini-2.0-flash")
+
+            mode = data.get("mode", "chat") # chat, trade, search, app
+
+            
+
+            if not msg: return {"status": "error", "message": "No message provided"}
+
+            
+
+            # Mode-specific logic
+
+            system_prompt = "You are Gemini Master, the supreme orchestrator of all integrated platforms (Firebase, Vercel, Supabase, Notion, etc.)."
+
+            
+
+            if mode == "trade":
+
+                system_prompt = "You are the Trading Sentinel. Accessing live market data and Supabase logs."
+
+                # 실시간 가격 정보 자동 주입 서비스 (예시: BTC)
+
+                prices = get_crypto_price("BTC")
+
+                wisdom = learning_engine.get_trading_lessons("ALL")
+
+                msg = f"[Live Market]: {prices}\n[Context: Trading Wisdom]\n{wisdom}\n\n[User Request]: {msg}"
+
+            
+
+            elif mode == "search":
+
+                system_prompt = "You are the Quantum Search engine. Utilizing DuckDuckGo, Tavily, and Google Search."
+
+                search_results = web_search_ddg(msg)
+
+                msg = f"[Web Search Results]:\n{search_results}\n\n[User Request]: {msg}"
+
+            
+
+            elif mode == "app":
+
+                app_id = data.get("app_id", "general")
+
+                app_prompts = {
+
+                    "coder": "You are a Senior Software Engineer specializing in GitHub Actions, Codespaces, and Cursor SSH.",
+
+                    "analyst": "You are a Market Analyst. Use Supabase data and exchange APIs for real-time insights.",
+
+                    "notion": "You are a Knowledge Manager. Help organize thoughts into Notion databases and rules.",
+
+                    "cloud_master": "You are the Cloud Architect. Manage Vercel, Render, and Firebase deployments.",
+
+                    "trader_alpha": "You are an Elite Algorithmic Trader. Specialized in high-frequency trading rules."
+
+                }
+
+                
+
+                # Context enhancement for Analyst
+
+                if app_id == "analyst":
+
+                    news = get_market_news("global market")
+
+                    # Load Auto-Generated Rules
+
+                    try:
+
+                        import glob
+
+                        rule_files = glob.glob("04_SYNC_DATA/LEARNED_RULES/*.json")
+
+                        loaded_rules = []
+
+                        for rf in rule_files[-3:]: # Load latest 3 rules
+
+                            with open(rf, "r", encoding="utf-8") as f:
+
+                                loaded_rules.append(json.load(f))
+
+                        rules_context = json.dumps(loaded_rules, ensure_ascii=False, indent=1)
+
+                    except: rules_context = "No rules yet."
+
+                    
+
+                    msg = f"[Context: Real-time News]\n{news}\n\n[Context: Auto-Generated Rules]\n{rules_context}\n\n[User Request]: {msg}"
+
+                
+
+                system_prompt = app_prompts.get(app_id, "You are a specialized AI assistant.")
+
+
+
+            # Multi-Brain Switching Logic (LiteLLM)
+
+            response = ask_any_model(msg, model)
+
+            return {"status": "success", "response": response, "mode": mode}
+
+        except Exception as e:
+
+            return {"status": "error", "message": str(e)}
+
+
+
+    @app.get("/api/apps/list")
+
+    async def api_list_apps():
+
+        """지원되는 AI 앱/모드 리스트 반환"""
+
+        return {
+
+            "status": "success",
+
+            "apps": [
+
+                {"id": "chat", "name": "Standard Chat", "icon": "💬", "desc": "Universal Intelligence"},
+
+                {"id": "trade", "name": "Trading Sentinel", "icon": "📈", "desc": "Market & Exchange Hub"},
+
+                {"id": "search", "name": "Quantum Search", "icon": "🔍", "desc": "Tavily + DDG Global Search"},
+
+                {"id": "app", "name": "App: Cloud Architect", "icon": "☁️", "app_id": "cloud_master"},
+
+                {"id": "app", "name": "App: Code Expert (SSH)", "icon": "💻", "app_id": "coder"},
+
+                {"id": "app", "name": "App: Notion Agent", "icon": "📓", "app_id": "notion"},
+
+                {"id": "app", "name": "App: Market Analyst", "icon": "📊", "app_id": "analyst"},
+
+                {"id": "app", "name": "App: Elite Trader", "icon": "🦅", "app_id": "trader_alpha"}
+
+            ]
+
+        }
+
+
+
+    @app.get("/api/debate/suggest")
+
+    async def api_debate_suggest():
+
+        """딥마인드 브레인이 현재 프로젝트/시장 상황에 맞는 토론 주제를 제안"""
+
+        prompt = "현재 인공지능 트레이딩 시스템을 구축 중이야. 우리 '딥마인드 위원회(The Council)'가 토론할 만한 아주 날카롭고 혁신적인 주제 3가지만 제안해줘. (예: 기술적 분석 vs 온체인 데이터, 퀀트 전략의 한계 등)"
+
+        try:
+
+            # 빠른 답변을 위해 gemini-2.0-flash 사용
+
+            suggestion = ask_any_model(prompt, "gemini-2.0-flash")
+
+            return {"status": "success", "suggestions": suggestion}
+
+        except:
+
+            return {"status": "error", "message": "Failed to generate suggestions"}
+
+
+
+    @app.get("/api/insights/latest")
+
+    async def api_get_insights(refresh: bool = False):
+
+        """자율분석 에이전트의 최신 인사이트 반환"""
+
+        from .autonomous_analyst import generate_autonomous_insight, INSIGHTS_FILE
+
+        
+
+        if refresh or not os.path.exists(INSIGHTS_FILE):
+
+            insight = generate_autonomous_insight()
+
+            if not insight: return {"status": "error", "message": "Analysis failed"}
+
+            return {"status": "success", "data": insight}
+
+        
+
+        try:
+
+            with open(INSIGHTS_FILE, "r", encoding="utf-8") as f:
+
+                return {"status": "success", "data": json.load(f)}
+
+        except:
+
+            return {"status": "error", "message": "Read error"}
+
+
+
+    # --- MCP 도구 (통합 지능) ---
+
+    @mcp.tool()
+
+    def get_shared_history(limit: int = 15) -> str:
+
+        """[통합 기억장치] 다른 IDE나 다른 시간대에 나눈 모든 채팅 기록을 불러옵니다. '하나의 뇌'처럼 작동하게 해줍니다."""
+
+        log_path = "shared_chat_history.json"
+
+        if not os.path.exists(log_path) and os.path.exists(os.path.join("..", log_path)): log_path = os.path.join("..", log_path)
+
+        if not os.path.exists(log_path): return "기록이 아직 없습니다. 대화를 시작하면 자동으로 이곳에 모입니다."
+
+        
+
+        try:
+
+            with open(log_path, "r", encoding="utf-8") as f:
+
+                history = json.load(f)
+
+                recent = history[-limit:]
+
+                return "\n".join([f"[{e['timestamp']}] {e['role']} ({e['ide']}): {e['content']}" for e in recent])
+
+        except: return "로그를 읽는 데 실패했습니다."
+
+
+
+    @mcp.tool()
+
+    def list_supported_models() -> str:
+
+        """[📋모델 리스트] 현재 시스템에서 사용 가능한 모든 AI 모델 목록을 보여줍니다."""
+
+        model_list = [
+
+            "--- Google Gemini ---",
+
+            "gemini-2.0-flash, gemini-2.0-pro, gemini-1.5-pro, gemini-2.5-alpha",
+
+            "",
+
+            "--- Anthropic Claude ---",
+
+            "claude-3.5-sonnet, claude-3.5-haiku, claude-3-opus",
+
+            "",
+
+            "--- OpenAI GPT ---",
+
+            "gpt-4o, gpt-4o-mini, o1-preview, o1-mini",
+
+            "",
+
+            "--- Perplexity (Search) ---",
+
+            "perplexity-sonar, perplexity-reasoning",
+
+            "",
+
+            "--- Groq (Llama, Fast) ---",
+            "llama-3.3-70b, llama-3.1-70b, mixtral-8x7b",
+            "",
+            "--- Hugging Face (Serverless) ---",
+            "hf/meta-llama/Llama-2-7b-hf, hf/mistralai/Mistral-7B-v0.1",
+            "",
+            "--- Other ---",
+            "grok, deepseek-v3"
+        ]
+        return "\n".join(model_list)
+
+
+
+    @mcp.tool()
+
+    def ask_any_model(question: str, model_type: str = "gemini-2.0-flash") -> str:
+
+        """[🧠올인원 브레인] 전 세계 모든 AI 모델을 호출합니다.
+
+           지원: gemini(2.0, 1.5), claude(3.5, Opus), gpt(4o, o1), grok, perplexity(sonar), llama(groq)"""
+        log_shared_chat("user", question, model_type)
+        
+        # [REFINED] Authorized Model Pool 
+        # Optimized for OpenRouter fallback to ensure high availability
+        model_map = {
+            # --- 5 IDE-Tier Models ---
+            "gemini-2.0-flash": "gemini/gemini-2.0-flash",
+            "gemini-2.0-pro": "gemini/gemini-2.0-pro-exp",
+            "gpt-4o": "openrouter/openai/gpt-4o",
+            "claude-3.5-sonnet": "openrouter/anthropic/claude-3.5-sonnet",
+            "gpt-4-turbo": "openrouter/openai/gpt-4-turbo",
+            
+            # --- 3 Specialized Claude Models ---
+            "claude-3.5-haiku": "openrouter/anthropic/claude-3.5-haiku",
+            "claude-3-opus": "openrouter/anthropic/claude-3-opus",
+
+            # --- Grok & Others ---
+            "grok": "openrouter/x-ai/grok-2",
+            
+            # --- Perplexity (Search AI) ---
+            "perplexity-sonar": "openrouter/perplexity/sonar",
+            
+            # --- Groq (Fast Llama) ---
+            "llama-3.3-70b": "groq/llama-3.3-70b-versatile"
+        }
+
+        model_id = model_map.get(model_type, model_type)
+        provider = model_id.split('/')[0] if '/' in model_id else "unknown"
+
+        # 1. Inject Master Context (Real-time Learning from Files)
+        context_prompt = ""
+        try:
+            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            rules_path = os.path.join(project_root, "04_SYNC_DATA", "Master_Rules.json")
+            if os.path.exists(rules_path):
+                with open(rules_path, "r", encoding="utf-8") as f:
+                    rules = json.load(f)
+                    context_prompt += f"\n[Master Rules]: {json.dumps(rules, ensure_ascii=False)}"
+        except: pass
+
+        full_question = f"{context_prompt}\n\nCurrent User Request: {question}"
+
+        # 플랫폼별 API 키 선택 및 OpenRouter 자동 폴백
+        keys = api_inventory.get(provider, [])
+        
+        # OpenRouter 전용 처리
+        if provider == "openrouter" or (not keys and provider != "gemini"):
+            or_key = os.getenv("OPENROUTER_API_KEY")
+            if or_key:
+                keys = [or_key]
+                if not model_id.startswith("openrouter/"):
+                    # Fallback mapping for OpenRouter
+                    or_map = {
+                        "anthropic": "openrouter/anthropic/",
+                        "openai": "openrouter/openai/",
+                        "xai": "openrouter/x-ai/",
+                        "google": "openrouter/google/"
+                    }
+                    if provider in or_map:
+                        model_id = model_id.replace(f"{provider}/", or_map[provider])
+                    else:
+                        model_id = f"openrouter/{model_id}"
+            
+        if not keys and provider == "gemini": 
+            keys = google_keys 
+
+        
+
+        # openrouter 특정 모델 처리
+
+        if model_type.startswith("or/"):
+
+            model_id = "openrouter/" + model_type[3:]
+
+            keys = api_inventory.get("openrouter", [os.getenv("OPENROUTER_API_KEY")])
+
+        
+
+        # 호출 시도 (최대 토큰 제한으로 쿼터 보호)
+
+        for k in (keys if keys else [""]):
+
+            try:
+
+                r = completion(
+
+                    model=model_id, 
+
+                    messages=[
+
+                        {"role": "system", "content": "You are Gemini Master, an autonomous AI system. You can save files by starting your response with 'SAVE_FILE:[path]' followed by the content. Example: 'SAVE_FILE:Rules/new_rule.json\n{...}'"},
+
+                        {"role": "user", "content": full_question}
+
+                    ], 
+
+                    api_key=k if k else None, 
+
+                    timeout=30,
+
+                    max_tokens=1000 # 최적화: 1000토큰 (기술 답변 짤림 방지)
+
+                )
+
+                ans = r.choices[0].message.content
+
+                
+
+                # [Smart Agent Interaction]
+
+                if ans.startswith("SAVE_FILE:"):
+
+                    try:
+
+                        file_info = ans.split("\n", 1)
+
+                        header = file_info[0]
+
+                        content = file_info[1] if len(file_info) > 1 else ""
+
+                        target_path = header.replace("SAVE_FILE:", "").strip()
+
+                        
+
+                        # Project Root normalization
+
+                        project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+                        full_save_path = os.path.join(project_root, target_path)
+
+                        
+
+                        os.makedirs(os.path.dirname(full_save_path), exist_ok=True)
+
+                        with open(full_save_path, "w", encoding="utf-8") as f:
+
+                            f.write(content)
+
+                        ans = f"✅ [AGENT] File saved to: {target_path}\n\n" + ans
+
+                    except Exception as fe:
+
+                        ans = f"⚠️ [AGENT] File save failed: {fe}\n\n" + ans
+
+
+
+                log_shared_chat("assistant", ans, model_type)
+
+                auto_save_safety_backup()
+
+                return ans
+
+            except Exception as e:
+
+                log(f"⚠️ {model_id} 실패: {str(e)[:50]}")
+
+                continue
+
+        return f"❌ {model_type} 호출 실패. API 키를 확인하시거나 다른 모델을 시도해 주세요."
+
+
+
+    @mcp.tool()
+
+    def web_search_ddg(query: str) -> str:
+
+        """[🔍DuckDuckGo 검색] 실시간 웹 정보를 검색합니다."""
+
+        try:
+
+            with DDGS() as ddgs:
+
+                results = [r for r in ddgs.text(query, max_results=5)]
+
+                if not results: return "검색 결과가 없습니다."
+
+                return "\n\n".join([f"[{r['title']}]\n{r['body']}\n({r['href']})" for r in results])
+
+        except Exception as e: return f"검색 중 오류 발생: {e}"
+
+
+
+    @mcp.tool()
+
+    def web_search_tavily(query: str) -> str:
+
+        """[🧠Tavily AI 검색] AI 최적화 웹 검색을 수행합니다 (API 키 필요)."""
+
+        tav_key = os.getenv("TAVILY_API_KEY")
+
+        if not tav_key: return "TAVILY_API_KEY가 설정되지 않았습니다."
+
+        try:
+
+            client = TavilyClient(api_key=tav_key)
+
+            result = client.search(query, search_depth="advanced")
+
+            if not result.get('results'): return "검색 결과가 없습니다."
+
+            return "\n\n".join([f"[{r['title']}]\n{r['content']}\n({r['url']})" for r in result['results'][:5]])
+
+        except Exception as e: return f"Tavily 검색 중 오류 발생: {e}"
+
+
+
+    @mcp.tool()
+
+    def read_file(path: str) -> str:
+
+        """파일 내용을 읽습니다."""
+
+        try:
+
+            with open(path, "r", encoding="utf-8") as f: return f.read()
+
+        except Exception as e: return str(e)
+
+
+
+    @mcp.tool()
+
+    def write_file(path: str, content: str) -> str:
+
+        """파일을 저장합니다."""
+
+        try:
+
+            with open(path, "w", encoding="utf-8") as f: f.write(content); return f"✅ 저장 완료: {path}"
+
+        except Exception as e: return str(e)
+
+
+
+    # --- [NEW] AI Self-Learning Tools (RAG Feedback Loop) ---
+
+    @mcp.tool()
+
+    def record_new_trade(symbol: str, action: str, reason: str) -> str:
+
+        """[학습:기록] 새로운 매매 진입을 기록합니다. 예: record_new_trade('BTC', 'BUY', 'RSI 30 touched')"""
+
+        return learning_engine.record_trade(symbol, action, reason)
+
+
+
+    @mcp.tool()
+
+    def update_trade_outcome(symbol: str, result: str, feedback: str) -> str:
+
+        """[학습:피드백] 매매 결과를 평가합니다. 예: update_trade_outcome('BTC', 'WIN', 'Good RSI signal')"""
+
+        return learning_engine.update_trade_result(symbol, result, feedback)
+
+
+
+    @mcp.tool()
+
+    def get_market_wisdom(symbol: str = "ALL") -> str:
+
+        """[학습:회상] 과거 매매 기록에서 교훈을 얻습니다."""
+
+        return learning_engine.get_trading_lessons(symbol)
+
+
+
+    @mcp.tool()
+
+    def get_crypto_price(symbol: str = "BTC") -> str:
+
+        """[📈실시간 시세] 업비트(KRW) 및 바이낸스(USDT) 실시간 가격을 조회합니다. (API 키 불필요)"""
+
+        results = []
+
+        try:
+
+            # 1. Upbit (Public API)
+
+            upbit_symbol = f"KRW-{symbol}"
+
+            r_up = requests.get(f"https://api.upbit.com/v1/ticker?markets={upbit_symbol}", timeout=5)
+
+            if r_up.status_code == 200:
+
+                data = r_up.json()[0]
+
+                results.append(f"Upbit: {data['trade_price']:,} KRW ({data['signed_change_rate']*100:+.2f}%)")
+
+        except: pass
+
+
+
+        try:
+
+            # 2. Binance (Public API)
+
+            bin_symbol = f"{symbol}USDT"
+
+            r_bin = requests.get(f"https://api.binance.com/api/v3/ticker/price?symbol={bin_symbol}", timeout=5)
+
+            if r_bin.status_code == 200:
+
+                data = r_bin.json()
+
+                results.append(f"Binance: ${float(data['price']):,.2f} USDT")
+
+        except: pass
+
+
+
+        if not results: return f"❌ {symbol} 시세를 불러올 수 없습니다."
+
+        return " | ".join(results)
+
+
+
+    @mcp.tool()
+
+    def get_market_news(query: str = "crypto market") -> str:
+
+        """[📰뉴스 브리핑] Investing.com, Reuters 등 주요 금융 뉴스를 검색하여 브리핑합니다."""
+
+        specialized_query = f"site:investing.com OR site:reuters.com {query} news"
+
+        return web_search_ddg(specialized_query)
+
+
+
+    @mcp.tool()
+    def update_master_instruction(instruction: str, update_intelligence_state: str = None) -> str:
+        """[💎지휘관 지시] 시스템의 핵심 규칙(Master Rules)에 새로운 지침을 추가하거나 지능 상태를 업데이트합니다."""
+        # ... (기존 로직 유지)
+        try:
+            from intelligent_asset_manager import IntelligenceAssetManager
+            iam = IntelligenceAssetManager()
+            iam.archive_asset("Command Update", instruction, "System Configuration Pivot", "Direct Master Rules Modification", ["Command", "Settings"])
+        except: pass
+        
+        try:
+            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            rules_path = os.path.join(project_root, "04_SYNC_DATA", "Master_Rules.json")
+            rules = {}
+            if os.path.exists(rules_path):
+                with open(rules_path, "r", encoding="utf-8") as f: rules = json.load(f)
+            rules["last_sync"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            rules["instructions"] = instruction
+            if update_intelligence_state: rules["intelligence_state"] = update_intelligence_state
+            with open(rules_path, "w", encoding="utf-8") as f:
+                json.dump(rules, f, indent=2, ensure_ascii=False)
+            return f"✅ 지휘관 지시 반영 및 자적 자산화 완료."
+        except Exception as e: return f"❌ 실패: {str(e)}"
+
+    @mcp.tool()
+    def capture_intelligence_asset(title: str, idea: str, value: str, strategy: str, tags: str = "Native") -> str:
+        """[💡지능 자산화] 현재의 중요한 아이디어, 가치, 구현 전략을 지능 자산으로 영구 박제합니다.
+           윈드서프 내부 대화를 실시간으로 자산화하는 데 사용됩니다."""
+        try:
+            from intelligent_asset_manager import IntelligenceAssetManager
+            iam = IntelligenceAssetManager()
+            tag_list = [t.strip() for t in tags.split(",")]
+            file_path = iam.archive_asset(title, idea, value, strategy, tag_list)
+            return f"✅ 지능 자산 박제 완료: {os.path.basename(file_path)}"
+        except Exception as e:
+            return f"❌ 자산화 실패: {str(e)}"
+
+    @mcp.tool()
+    def system_emergency_patch(target_module: str, patch_content: str, reason: str = "Commander Order") -> str:
+        """[⚡긴급 패치] 시스템 핵심 모듈(HEALING_CORE, BOT_CORE 등)에 대한 긴급 코드를 주입합니다.
+           지휘관님이 '이거 고쳐'라고 하면 안티그래비티가 즉시 이 도구를 사용하여 코드를 수술합니다."""
+        valid_targets = {
+            "HEALING_CORE": "ANTIGRAVITY_HEALING_CORE.py",
+            "LEARNING_ENGINE": "01_CENTRAL_BRAIN/App/learning_engine.py",
+            "SERVER": "01_CENTRAL_BRAIN/App/server.py"
+        }
+        
+        target_file = valid_targets.get(target_module.upper())
+        if not target_file:
+            return f"❌ 유효하지 않은 타겟입니다. 가능 목록: {', '.join(valid_targets.keys())}"
+            
+        try:
+            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            full_path = os.path.join(project_root, target_file)
+            
+            # 백업 생성
+            ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_path = f"{full_path}.{ts}.bak"
+            shutil.copy2(full_path, backup_path)
+            
+            # 패치 적용 (단순 덮어쓰기 or 스마트 병합 - 현재는 안전을 위해 전체 교체 전용으로 설계)
+            # 주의: patch_content는 전체 파일 내용이어야 함. 부분 수정은 별도 로직 필요.
+            with open(full_path, "w", encoding="utf-8") as f:
+                f.write(patch_content)
+                
+            log(f"⚡ [EMERGENCY PATCH] {target_module} 패치 완료 (Reason: {reason})")
+            return f"✅ {target_module} 긴급 패치 완료. 백업: {os.path.basename(backup_path)}"
+        except Exception as e:
+            return f"❌ 패치 실패: {str(e)}"
+    # [Active Mining Loop] 자율 자산 채굴 스레드
+    def autonomous_asset_miner():
+        """1시간마다 프로젝트를 스캔하여 새로운 아이디어/알고리즘을 스스로 자산화합니다."""
+        while True:
+            try:
+                time.sleep(3600) # 1시간 주기
+                log("🕵️‍♂️ [MINER] 자율 자산 채굴 스캔 시작...")
+                # 실제 채굴 로직은 IntelligenceAssetManager의 배치 모드를 호출할 예정
+            except: pass
+
+    # --- 서버 구동 로직 ---
+
+    def start_api():
+
+        # Render/IDX 등 클라우드 환경에서 포트 바인딩을 위해 0.0.0.0과 PORT 환경변수 사용
+
+        port = int(os.getenv("PORT", 8000))
+
+        uvicorn.run(app, host="0.0.0.0", port=port, log_level="error")
+
+
+
+    if __name__ == "__main__":
+
+        log("\n" + "="*50)
+
+        log("🚀 GEMINI MASTER: UNIFIED BRAIN ONLINE")
+
+        log("   [API] Dashboard Ready at http://localhost:8000")
+
+        log("   [MCP] Integrated Mode (Cloud/Local Adaptive)")
+
+        log("="*50)
+
+        
+
+        # [IDX/Cloud/Windsurf 최적화]
+
+        # Windsurf/Claude는 isatty()가 False이므로 이를 클라우드로 오판하지 않게 수정
+
+        is_actually_cloud = os.getenv("IDX_WORKSPACE_ID") or os.getenv("RENDER") or os.getenv("PORT")
+
+        
+
+        if is_actually_cloud:
+            log("☁️ ���라우드 환경 감지: FastAPI(HTTP) 모드로 실행합니다.")
+            
+            # [NEW] Cloud Miner Start
+            miner_thread = threading.Thread(target=autonomous_asset_miner, daemon=True)
+            miner_thread.start()
+            
+            start_api()
+
+        else:
+
+            log("🏠 로컬/IDE 환경: Stdio(MCP)와 HTTP(API)를 병렬로 실행합니다.")
+
+            # API 서버를 별도 스레드에서 실행
+
+            api_thread = threading.Thread(target=start_api, daemon=True)
+
+            api_thread.start()
+            
+            # [NEW] Local Miner Start (Active Intelligence)
+            miner_thread = threading.Thread(target=autonomous_asset_miner, daemon=True)
+            miner_thread.start()
+            log("⛏️ [MINER] 자율 가치 채굴 엔진 가동 (Cycle: 1h)")
+            
+            try:
+
+                # Main 스레드에서 MCP Stdio 서버 실행 (윈드서프 연동 핵심)
+
+                mcp.run()
+
+            except (KeyboardInterrupt, SystemExit):
+
+                log("🛑 시스템 종료 요청을 받았습니다.")
+
+            except Exception as e:
+
+                log(f"⚠️ MCP 실행 오류: {e}")
+
+
+
+except Exception:
+
+    log("\n❌ [FAIL]:")
+
+    traceback.print_exc()