diff --git "a/shadow_brain_core/web_server.py" "b/shadow_brain_core/web_server.py"
--- "a/shadow_brain_core/web_server.py"
+++ "b/shadow_brain_core/web_server.py"
@@ -1,537 +1,42 @@
 # -*- coding: utf-8 -*-
-import os
-import re
-import secrets
-import json
-import uuid
-import base64
-import random
-import logging
-import time
-import subprocess
-import sys
-from collections import deque
-from datetime import datetime, timezone, timedelta
-import threading
-import importlib.util
-import yaml # Added for frontmatter parsing
-try:
-    import pyautogui
-    HAS_GUI = True
-except Exception:
-    # 🔱 Headless Cloud Fallback
-    HAS_GUI = False
-    pyautogui = None
-import requests
-from flask import Flask, render_template, jsonify, send_from_directory, request, Response, stream_with_context
-from dotenv import load_dotenv
-from google import genai
-from google.genai import types
-
-logger = logging.getLogger(__name__)
-
-
-def _sanitize_a2ui_for_relay(text: str) -> str:
-    """디스코드/텔레그램 같은 비대화형 릴레이용으로 A2UI 카드 블록을 평문화한다.
-
-    헤임달 Flutter 전용 ```imperial-*``` 블록(미디어 그리드/유튜브/지도/선택카드)은
-    외부 채널에서 렌더링되지 않고 날것 JSON으로 노출되므로:
-      - imperial-media / imperial-youtube / imperial-3d / imperial-map(s):
-        블록 안의 URL만 추출해 평문 줄로 남긴다(디스코드가 자동 임베드).
-      - imperial-ask 및 그 외 imperial-* 블록: 그냥 제거.
-    """
-    if not text or '```imperial-' not in text:
-        return (text or '').strip()
-
-    url_kinds = ('media', 'youtube', '3d', 'map', 'maps')
-
-    def _extract_urls(block: str):
-        seen = []
-        # imperial-media는 JSON이라 item별 대표 URL(url→preview→page)만 골라낸다.
-        try:
-            inner = re.sub(r'^```imperial-[\w-]+\s*|\s*```$', '', block.strip())
-            data = json.loads(inner)
-            for it in (data.get('items') or []):
-                u = it.get('url') or it.get('preview') or it.get('page') or it.get('download')
-                if u and u not in seen:
-                    seen.append(u)
-        except Exception:
-            pass
-        if not seen:
-            for u in re.findall(r'https?://[^\s"\'\\)]+', block):
-                if u not in seen:
-                    seen.append(u)
-        return seen[:5]
-
-    def _repl(m):
-        kind = (m.group(1) or '').lower()
-        if kind in url_kinds:
-            urls = _extract_urls(m.group(0))
-            return ('\n' + '\n'.join(urls) + '\n') if urls else ''
-        return ''
-
-    text = re.sub(r'```imperial-([\w-]+)[\s\S]*?```', _repl, text).strip()
-    # [TOOL_USE: ...] 패턴 제거 — 릴레이 채널(디스코드/텔레그램)에서 날것 노출 방지
-    text = re.sub(r'\[TOOL_USE:[^\]]*\]\s*', '', text).strip()
-    return text
-
-
-from utils.emotion import extract_emotion as _extract_emotion_from_text, strip_emotion_tags as _strip_emotion_tags
-
-
-# [🔱 Imperial v2.5.2] Standardized Path Resolution (PyInstaller EXE 호환)
-# PyInstaller로 패키징된 EXE 실행 시 __file__은 임시 폴더를 가리킴.
-# sys.frozen이 True이면 실제 EXE 위치(sys.executable)를 기준으로 경로를 잡습니다.
-if getattr(sys, 'frozen', False):
-    # EXE 모드: dist/ShadowBrain/ 내부가 core_root
-    core_root = os.path.dirname(os.path.abspath(sys.executable))
-else:
-    # 일반 Python 실행 모드
-    core_root = os.path.dirname(os.path.abspath(__file__))
-project_root = os.path.dirname(core_root) # One level up to d:\Git_Work\jarvis_taemin
-
-# [🔱 Imperial Writable Data Root]
-# 배포본(.exe)은 Program Files 등 쓰기가 막힌 보호 폴더에 설치된다. 이 경우 project_root가
-# Program Files를 가리켜 docker_data/로그/설정 생성 시 PermissionError(WinError 5)로 부팅이
-# 멈춘다. frozen(.exe) 또는 LOCAL_AGENT_MODE에서는 project_root를 쓰기 가능한 사용자 폴더
-# (%LOCALAPPDATA%\TaeminGames\ShadowBrain)로 강제 리다이렉트한다. (읽기용 core_root는 유지)
-def _resolve_writable_data_root():
-    explicit = os.environ.get("IMPERIAL_DATA_ROOT")
-    if explicit:
-        base = explicit
-    else:
-        local_base = os.environ.get("LOCALAPPDATA", os.path.expanduser("~"))
-        base = os.path.join(local_base, "TaeminGames", "ShadowBrain")
-    try:
-        os.makedirs(base, exist_ok=True)
-    except Exception:
-        return None
-    return base
-
-if getattr(sys, 'frozen', False) or os.environ.get("LOCAL_AGENT_MODE", "false").lower() == "true":
-    _writable_root = _resolve_writable_data_root()
-    if _writable_root:
-        project_root = _writable_root
-        print(f"[SYSTEM] -> Writable data root: {project_root}", flush=True)
-
-def _read_shadow_version() -> str:
-    """VERSION 파일을 읽어 버전 문자열을 반환합니다."""
-    version_path = os.path.join(core_root, "VERSION")
-    if os.path.exists(version_path):
-        try:
-            with open(version_path, 'r', encoding='utf-8') as f:
-                return f.read().strip()
-        except: pass
-    return "2.6.72" # Fallback
-
-# Add core directory and tools to sys.path before any local imports
-sys.path.append(core_root) 
-sys.path.append(os.path.join(project_root, "scripts", "tools"))
-
-# [🔱 Imperial] Persistent Console Title
-def set_imperial_title(title_name):
-    if sys.platform == "win32":
-        import ctypes
-        try:
-            ctypes.windll.kernel32.SetConsoleTitleW(title_name)
-        except Exception:
-            pass
-    else:
-        sys.stdout.write(f"\033]2;{title_name}\007")
-        sys.stdout.flush()
-
-print("[SYSTEM] Booting Imperial Shadow Brain Core...", flush=True)
-set_imperial_title("SHADOW BRAIN (Core Intelligence) - Port 18700")
-
-
-# Load environment variables from .env if it exists
-load_dotenv()
-
-# [🔱 Imperial Local Agent Mode Auto-Detection]
-# 1. sys.frozen이 True이면 PyInstaller로 빌드된 .exe 배포본 상태입니다.
-# 2. 배포본은 기본적으로 '로컬 에이전트 모드(Stateless)'로 작동하도록 자동 설정합니다.
-if getattr(sys, 'frozen', False):
-    LOCAL_AGENT_MODE = True
-    os.environ["LOCAL_AGENT_MODE"] = "true" # [🔱] 하위 모듈(sovereign_memory 등) 인식을 위해 환경변수 강제 주입
-    print("[SYSTEM] 🔱 Imperial Standalone Executable (.exe) detected.", flush=True)
-    print("[SYSTEM] -> Auto-activating Local Agent Mode (Stateless).", flush=True)
-else:
-    # 소스 코드로 실행 중일 때만 .env 설정을 따릅니다.
-    LOCAL_AGENT_MODE = os.environ.get("LOCAL_AGENT_MODE", "false").lower() == "true"
-
-# Imperial Core Modules
-print("[SYSTEM] -> Loading Imperial Core Modules...", flush=True)
-import gdrive_sync
-import cloud_tool
-import phantom_sandbox
-# psycopg2는 설치 환경에서만 활성화 (Stateless 배포 호환). 미설치 시 DB 엔드포인트만 비활성.
-try:
-    import psycopg2
-except ImportError:
-    psycopg2 = None
-from werkzeug.security import check_password_hash, generate_password_hash
-from sovereign_task_manager import task_manager
-import quota_manager
-from quota_manager import ImperialQuotaManager, CopilotUsageManager
-from aegis_link import neural_link
-from sovereign_browser_agent import SovereignMissionAgent
-from imperial_r2_uploader import ImperialR2Uploader
-from compaction import compaction_engine
-print("[SYSTEM] -> Core Modules Loaded.", flush=True)
-
-
-from guardian_monitor import guardian_monitor
-
-from db_util import get_db_connection
-from telegram_service import telegram_bot
-from discord_service import discord_bot
-from tasks_util import execute_shell_command, _post_to_gbb, _analyze_sync_failure
-print("[SYSTEM] -> Loading Blueprints...", flush=True)
-from blueprints.system_routes import system_bp
-from blueprints.media_routes import media_bp
-from blueprints.chat_routes import chat_bp, init_chat_logic
-from blueprints.admin_routes import admin_bp, init_admin_logic
-from blueprints.agent_routes import agent_bp, init_agent_logic
-from blueprints.security_routes import security_bp, init_security_logic
-from blueprints.deployment_routes import deploy_bp, init_deploy_logic
-from blueprints.report_routes import report_bp, init_report_logic
-from blueprints.parallel_routes import parallel_bp, init_parallel_logic
-from blueprints.mcp_routes import mcp_bp
-from blueprints.transcribe_routes import transcribe_bp  # [🔱 미디어 전사 API] /api/transcribe/*
-from blueprints.obsidian_routes import obsidian_bp  # [🗂️ 옵시디언 지식 레이어] /api/obsidian/* — 로컬 전용
-print("[SYSTEM] -> Blueprints Loaded.", flush=True)
-
-from services.brain_service import init_service_logic, get_brain_response_sync
-import services.brain_service as brain_service
-from compaction import CompactionEngine
-from sovereign_memory import memory_write_vector
-
-
-# Imperial Remote Vision Service & Sovereign Engine
-try:
-    import remote_vision_service
-    import sovereign_engine
-    import sovereign_memory
-except ImportError as e:
-    print(f"[SYSTEM] -> Remote services loading warning: {e}")
-except Exception as e:
-    print(f"[SYSTEM] -> Core engine initialization warning: {e}")
-
-# --- [🔱 Imperial Log Monitoring] ---
-class ImperialLogHandler(logging.Handler):
-    """[🔱 Imperial] Custom logging handler to pipe all logs into the global buffer."""
-    def __init__(self, log_queue):
-        super().__init__()
-        self.log_queue = log_queue
-        # Use a consistent timestamp format same as StreamTee
-        self.setFormatter(logging.Formatter('[%(asctime)s] %(name)s: %(message)s', datefmt='%H:%M:%S'))
-
-    def emit(self, record):
-        try:
-            msg = self.format(record)
-            self.log_queue.append(msg)
-        except Exception:
-            self.handleError(record)
-
-class StreamTee:
-    """[🔱 Imperial] Custom stream wrapper to copy stdout/stderr to the global log buffer."""
-    def __init__(self, stream, log_queue):
-        self.stream = stream
-        self.log_queue = log_queue
-
-    def write(self, data):
-        self.stream.write(data)
-        if isinstance(data, bytes):
-            try:
-                data = data.decode('utf-8', errors='replace')
-            except:
-                return # Skip if undecodable
-        
-        text = data.strip()
-        if text:
-            # [🔱 Imperial] Mute periodic polling logs from stdout capture
-            # Stricter filtering to prevent polling loop visibility
-            poll_keywords = [
-                "/api/logs/shadow-brain", 
-                "/api/system/monitor/r2", 
-                "/api/status", 
-                "/health",
-                "GET /api/logs", 
-                "method: get"
-            ]
-            if any(kw in text for kw in poll_keywords):
-                return
-
-            # Format like a log message for consistency
-            timestamp = datetime.now().strftime('%H:%M:%S')
-            self.log_queue.append(f"[{timestamp}] [STDOUT] {text}")
-
-    def flush(self):
-        self.stream.flush()
-
-SHADOW_BRAIN_LOGS = deque(maxlen=30)
-
-def capture_logs():
-    """Starts capturing stdout, stderr, and root logger into the global log queue."""
-    # 1. Pipe Standard Output
-    sys.stdout = StreamTee(sys.stdout, SHADOW_BRAIN_LOGS)
-    sys.stderr = StreamTee(sys.stderr, SHADOW_BRAIN_LOGS)
-    
-    # 2. Add Logging Handler to Root
-    root_logger = logging.getLogger()
-    handler = ImperialLogHandler(SHADOW_BRAIN_LOGS)
-    root_logger.addHandler(handler)
-    logger.info("🔱 Imperial Neural Log Stream Integrated.")
-
-capture_logs()
-
-# --- [Imperial Core] Dynamic R2 Resolution Helpers ---
-def get_imperial_r2_account_name():
-    """Returns the R2 account name based on the current environment."""
-    app_env = os.environ.get("APP_ENV", "local").lower()
-    return "live" if app_env == "live" else "vault"
-
-
-# --- [🔱 Imperial Health Check] ---
-# --- [🔱 Imperial Context Caching] ---
-_IMPERIAL_CONTEXT_CACHE = {
-    "agents": "",
-    "run_info": "",
-    "last_mtime_agents": 0,
-    "last_mtime_run": 0
-}
-
-def _load_imperial_context():
-    """
-    [🔱 High-Performance Comprehensive Context Loader - V3 Final]
-    제국의 모든 정체성(수호자, 아키텍처, 바하무트 등 시스템 자산)을 AGENTS.md와 JARVISRUN.md에서 정밀하게 추출합니다.
-    """
-    global _IMPERIAL_CONTEXT_CACHE
-    
-    agents_path = os.path.join(project_root, "AGENTS.md")
-    run_info_path = os.path.join(project_root, "JARVISRUN.md")
-    
-    try:
-        # 1. AGENTS.md 파싱 (수호자 명단 ~ 하단 전체)
-        # 9번 섹션(수호자 연합) 이후의 모든 규약과 정보를 포함하여 시스템 정체성 확립
-        if os.path.exists(agents_path):
-            current_mtime = os.path.getmtime(agents_path)
-            if current_mtime > _IMPERIAL_CONTEXT_CACHE["last_mtime_agents"]:
-                with open(agents_path, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                    match = re.search(r'## 9\. 🔱 황실 수호자 연합.*', content, re.DOTALL)
-                    if match:
-                        _IMPERIAL_CONTEXT_CACHE["agents"] = match.group(0).strip()
-                    else:
-                        _IMPERIAL_CONTEXT_CACHE["agents"] = content[:3000] # 최후의 수단
-                _IMPERIAL_CONTEXT_CACHE["last_mtime_agents"] = current_mtime
-        
-        # 2. JARVISRUN.md 파싱 (아키텍처 ~ 끝까지)
-        # 3번 섹션(아키텍처) 및 4번(수호자 위계)을 포함하여 바하무트 등 시스템 엔티티 인지
-        if os.path.exists(run_info_path):
-            current_mtime = os.path.getmtime(run_info_path)
-            if current_mtime > _IMPERIAL_CONTEXT_CACHE["last_mtime_run"]:
-                with open(run_info_path, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                    # '## 3. 아키텍처' 이후의 모든 내용을 가져와서 시스템 구조를 학습시킴
-                    match = re.search(r'## 3\. 아키텍처.*', content, re.DOTALL)
-                    if match:
-                        _IMPERIAL_CONTEXT_CACHE["run_info"] = match.group(0).strip()
-                    else:
-                        _IMPERIAL_CONTEXT_CACHE["run_info"] = ""
-                _IMPERIAL_CONTEXT_CACHE["last_mtime_run"] = current_mtime
-                
-    except Exception as e:
-        print(f"[🔱 Context Loader] Error loading context: {e}")
-        
-    return f"{_IMPERIAL_CONTEXT_CACHE['agents']}\n\n{_IMPERIAL_CONTEXT_CACHE['run_info']}"
-
-def get_imperial_r2_root():
-    """Returns the base public URL for the current environment's R2 account."""
-    from cloud_tool import R2_ACCOUNTS
-    acc_name = get_imperial_r2_account_name()
-    return R2_ACCOUNTS.get(acc_name, {}).get("public_url", "")
-
-def resolve_imperial_profile_url(p_url):
-    """Resolves a relative profile URL to a full R2 URL based on environment."""
-    if not p_url: return p_url
-    if p_url.startswith('/images/portraits/'):
-        root = get_imperial_r2_root()
-        return f"{root.rstrip('/')}/{p_url.lstrip('/')}"
-    return p_url
-
-# --- [🔱 Imperial Core] Shadow Brain Engine Port 18700 ---
-# Logic and Management have been consolidated to Django (Port 18701).
-# This engine now focuses on High-Performance Chat, Agency, and GPU tasks.
-
-# get_db_connection is imported from db_util
-
-# [REMOVED] ensure_db_schema_ready is now handled by Django Fortress (18701)
-
-
-
-# Global store for GitHub OAuth sessions
-
-GITHUB_AUTH_SESSIONS = {}
-
-
-
-# Load environment variables from .env if it exists
-
-load_dotenv()
-
-
-
-# Disable Flask logging for a cleaner terminal
-
-log = logging.getLogger('werkzeug')
-
-log.setLevel(logging.ERROR)
-
-
-
-# --- GitHub Copilot Logic ---
-
-# Caches the session-based Copilot token
-
-GITHUB_COPILOT_CACHE = {
-
-    "token": None,
-
-    "expires_at": 0,
-
-    "base_url": "https://api.individual.githubcopilot.com"
-
-}
-
-
-
-# Caches the last few proactive messages to avoid repetition
-
-
-
-
-
-# Phase 41: Graceful Reintegration State
-# RAG Management Globals (Debounce & Thread Safety)
-rag_timers = {}    # {guardian: Timer}
-rag_pending = {}   # {guardian: (content, metadata)}
-rag_lock = threading.Lock()
-
-is_syncing = False
-
-
-
-# Proactive Chat Configuration Default
-
-CHAT_CONTEXT_LIMIT = 50 # [IMPERIAL] Default context window size (overridden by JARVIS_SHADOW_SETTINGS.json)
-
-def _get_chat_context_limit(project_root_path: str) -> int:
-    """JARVIS_SHADOW_SETTINGS.json에서 context_limit을 읽어 Hot-Reload로 반환합니다."""
-    try:
-        settings_file = os.path.join(project_root_path, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_SHADOW_SETTINGS.json")
-        if os.path.exists(settings_file):
-            with open(settings_file, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            val = data.get("context_limit")
-            if isinstance(val, int) and 5 <= val <= 500:
-                return val
-    except Exception:
-        pass
-    return CHAT_CONTEXT_LIMIT
-
-
-
-PROACTIVE_CONFIG_FILE = None # Will be set in setup_project
-
-# Proactive Topic Mapping (Korean to English Key)
-
-# --- [🔱 Imperial Media Services] (Moved to media_service.py) ---
-from services.media_service import fetch_global_trends, fetch_youtube_trending, fetch_youtube_by_keyword, fetch_joke
-
-def get_imperial_context(project_root, guardian_id="jarvis"):
-    """Gathers situational and hierarchical awareness for the Shadow Brain, supporting OpenClaw-style Soul logic."""
-    context = f"\n[IMPERIAL SITUATIONAL AWARENESS - TARGET: {guardian_id.upper()}]\n"
-
-    # 1. Determine Workspace Path
-    # Default: OpenClaw workspace for Aizen/Gilgamesh, or specialized folders for others
-    workspace_map = {
-        "jarvis": os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun"),
-        "aris": os.path.join(project_root, "docker_data", "shared_workspace", "Aris")
-    }
-    
-    workspace_path = workspace_map.get(guardian_id.lower())
-    
-    # If no specific workspace, check if a folder exists in docker_data/shared_workspace
-    if not workspace_path:
-        potential_path = os.path.join(project_root, "docker_data", "shared_workspace", guardian_id.capitalize())
-        if os.path.exists(potential_path):
-            workspace_path = potential_path
-
-    # 2. Inject Soul Bridge (IDENTITY.md, SOUL.md, USER.md)
-    if workspace_path and os.path.exists(workspace_path):
-        soul_files = ["IDENTITY.md", "SOUL.md", "USER.md", "AGENTS.md", "BOOTSTRAP.md", "TOOLS.md"]
-        context += f"--- [{guardian_id.upper()}] SOUL CLUSTER (Workspace: {os.path.basename(workspace_path)}) ---\n"
-        for soul_file in soul_files:
-            file_path = os.path.join(workspace_path, soul_file)
-            if os.path.exists(file_path):
-                try:
-                    with open(file_path, 'r', encoding='utf-8') as f:
-                        context += f"\n[{soul_file}]\n{f.read()}\n"
-                except Exception as e:
-                    context += f"\n[{soul_file} LOAD ERROR: {e}]\n"
-    else:
-        # Fallback to legacy SKILL.md if no workspace found
-        persona_file = os.path.join(project_root, ".agent", "skills", "jarvis_guardian_personas", "SKILL.md")
-        if os.path.exists(persona_file):
-            try:
-                with open(persona_file, 'r', encoding='utf-8') as f:
-                    context += "--- 제국 수호자 페르소나 (LEGACY SKILL.md) ---\n" + f.read() + "\n"
-            except Exception as e:
-                context += f"--- 제국 수호자 페르소나 로드 실패: {e} ---\n"
-
-    # 3. Inject Imperial Permanent Rules (AGENTS.md from root)
-    # This is a global rule file that applies to all
-    agents_rules_file = os.path.join(project_root, "AGENTS.md")
-    if os.path.exists(agents_rules_file):
-        try:
-            with open(agents_rules_file, 'r', encoding='utf-8') as f:
-                context += "--- 제국 영구 운영 규약 (GLOBAL AGENTS.md) ---\n" + f.read() + "\n"
-        except Exception as e:
-            context += f"--- 제국 운영 규약 로드 실패: {e} ---\n"
-
-    context += f"현재 서버 시간: {time.strftime('%Y-%m-%d %H:%M:%S')}\n"
-    return context
-
-
-def load_guardian_emails():
-    path = os.path.join(project_root, 'docker_data', 'shared_workspace', 'JarvisRun', 'JARVIS_GUARDIAN_EMAILS.json')
-    if not os.path.exists(path):
-        return {}
-    try:
-        with open(path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except Exception as e:
-        logger.error(f"[Emails] Load error: {e}")
-        return {}
-
-def save_guardian_emails(emails):
-    path = os.path.join(project_root, 'docker_data', 'shared_workspace', 'JarvisRun', 'JARVIS_GUARDIAN_EMAILS.json')
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    try:
-        with open(path, 'w', encoding='utf-8') as f:
-            json.dump(emails, f, indent=4, ensure_ascii=False)
-        return True
-    except Exception as e:
-        logger.error(f"[Emails] Save error: {e}")
-        return False
+"""Shadow Brain Flask app factory (create_web_server).
 
+모듈 수준 헬퍼: web_server_prelude
+"""
+from web_server_prelude import *  # noqa: F401,F403
+# ⚠️ `import *` 는 밑줄(_) 접두 이름을 가져오지 않는다(prelude 에 __all__ 없음).
+#    분해로 prelude 로 옮겨간 밑줄 헬퍼는 명시적으로 import해야 NameError 가 안 난다.
+from web_server_prelude import (  # noqa: F401
+    _read_shadow_version,
+    _sanitize_a2ui_for_relay,
+)
 
 def create_web_server(project_root, jarvisrun_engine, cluster=None, app_instance=None):
 
     # [🔱 Imperial] Re-enforce title on server creation
     set_imperial_title("SHADOW BRAIN (Core Intelligence) - Port 18700")
 
+    # 📜 [상시 파일 로그] 소환 주체가 stdout을 /dev/null로 버려도(태미니 CLI 헤드리스
+    # 소환 등) 서버 로그는 항상 남는다 — ~/TaeminGames/ShadowBrain/shadow_server.log
+    # (5MB × 2 회전). 디버깅 때마다 "로그가 없다"로 재기동하던 낭비 제거(2026-07-10).
+    try:
+        import logging as _logging
+        from logging.handlers import RotatingFileHandler as _RFH
+        _logdir = os.path.join(os.path.expanduser("~"), "TaeminGames", "ShadowBrain")
+        os.makedirs(_logdir, exist_ok=True)
+        _root = _logging.getLogger()
+        _logfile = os.path.join(_logdir, "shadow_server.log")
+        if not any(getattr(h, "baseFilename", "") == _logfile for h in _root.handlers):
+            _fh = _RFH(_logfile, maxBytes=5 * 1024 * 1024, backupCount=2, encoding="utf-8")
+            _fh.setFormatter(_logging.Formatter(
+                "%(asctime)s %(levelname)s %(name)s: %(message)s"))
+            _fh.setLevel(_logging.INFO)
+            _root.addHandler(_fh)
+            if _root.level > _logging.INFO or _root.level == _logging.NOTSET:
+                _root.setLevel(_logging.INFO)
+    except Exception as _log_err:
+        print(f"[Imperial Log] 파일 로그 핸들러 설치 실패(무해): {_log_err}")
+
     heimdall_build_path = os.path.normpath(os.path.join(project_root, "portal-heimdall", "build", "web"))
     legacy_ui_path = os.path.normpath(os.path.join(project_root, "scripts", "jarvisrun", "ui"))
 
@@ -656,6 +161,7 @@ def create_web_server(project_root, jarvisrun_engine, cluster=None, app_instance
     app.jarvis_brain = None
 
     # Register blueprints that do not require dependency injection immediately
+    app.register_blueprint(auth_gate_bp)  # 🔐 공개 배포(HF) 인증 게이트 — SHADOW_PUBLIC_GATE=1일 때만 동작
     app.register_blueprint(system_bp)
     app.register_blueprint(media_bp)
     app.register_blueprint(parallel_bp)
@@ -777,502 +283,14 @@ def create_web_server(project_root, jarvisrun_engine, cluster=None, app_instance
                 "message": f"LM Studio proxy failed: {e}",
             }), 502
 
-    @app.route('/v1/chat/completions', methods=['POST', 'OPTIONS'])
-    def openai_chat_completions():
-        """🔱 OpenAI API 호환 엔드포인트"""
-        if request.method == 'OPTIONS':
-            return '', 204
-            
-        data = request.json or {}
-        model = data.get("model", jarvis_brain.primary_model if jarvis_brain else "gemini-3.1-flash-lite")
-        messages = data.get("messages", [])
-        
-        from google import genai
-        from google.genai import types
-        import base64
-        import requests
-        
-        system_instruction = ""
-        user_contents = []
-        # 🔱 [최후 폴백] "당신은 '{target_display_name}'입니다"로 모델 프롬프트에 그대로 박히는
-        # 값이라, 정체성이 하나도 안 잡힌 경우 그럴듯한 실명("그림자 두뇌" 등)을 흉내내지 않도록
-        # 누가 봐도 미확인 상태임을 알 수 있는 값으로 둔다(shadow_brain 대상은 아래에서 SOUL로 확정됨).
-        target_display_name = "미확인 수호자 (Unidentified Guardian)"
-
-        try:
-            # [🔱 V1.0.0 Imperial Fail-Fast Validation Law]
-            # 환경 격리 및 엄격 검증 규약에 의거, 필수 자격(Aegis URL 및 마왕님 세션 인증 키)이 결여된 경우 
-            # 낡은 지식으로 우회(Fallback)해 거짓말하게 방치하지 않고 즉시 400 에러를 반환하여 문제 상황을 가시화합니다.
-            _openclaw_aegis_url = request.headers.get("X-Aegis-URL")
-            # 🔱 [Aegis URL 정규화] shadow_brain 헬퍼(aegis_link/chat_service/도구)는 모두
-            # {aegis_url}/api/... 형태로 /api를 직접 덧붙인다. 헤임달 baseUrl은 이미 '/api'로
-            # 끝나므로(local Shadow 경로), 그대로 쓰면 '/api/api/...' → 404가 난다(예: search_media).
-            # 들어온 URL이 '/api' 또는 '/api/'로 끝나면 한 번 벗겨 bare host로 통일한다.
-            if _openclaw_aegis_url:
-                _trimmed = _openclaw_aegis_url.strip().rstrip("/")
-                if _trimmed.endswith("/api"):
-                    _trimmed = _trimmed[:-4]
-                _openclaw_aegis_url = _trimmed
-            session_key = request.headers.get("X-OpenClaw-Session-Key", "")
-            
-            if not _openclaw_aegis_url or _openclaw_aegis_url.strip() == "":
-                logger.error("[Fail-Fast Violation] ❌ 필수 헤더 'X-Aegis-URL' 누락됨.")
-                return jsonify({
-                    "error": "Stateless Aegis Connection Error",
-                    "message": "❌ [제국 통신 장애] 필수 백엔드 경로(X-Aegis-URL)가 제공되지 않았습니다. 프론트엔드 연결 구성을 확인하십시오."
-                }), 400
-
-            if not session_key or session_key.strip() == "" or "anonymous" in session_key.lower():
-                logger.error(f"[Fail-Fast Violation] ❌ 필수 세션 키 'X-OpenClaw-Session-Key' 누락 또는 익명 접속 감지: {session_key}")
-                return jsonify({
-                    "error": "Imperial Session Key Violation",
-                    "message": "❌ [제국 인증 장애] 유효한 제국 세션 신분증(X-OpenClaw-Session-Key)이 누락되었습니다. 마왕님 계정의 로그인 토큰 갱신 또는 새로고침이 필요합니다."
-                }), 400
-
-            target_guardian = "shadow_brain" 
-            if session_key.startswith("agent:"):
-                # agent:<agent_id>:<sender_uuid>
-                parts = session_key.split(":")
-                if len(parts) >= 2: target_guardian = parts[1]
-            elif "/" in model:
-                target_guardian = model.split("/")[-1]
-
-            from blueprints.chat_routes import _resolve_persona_id, _build_system_instruction, _load_recent_history_context
-            from sovereign_memory import get_secret, _sanitize_db_url
-            target_persona_id = _resolve_persona_id(target_guardian, aegis_url=_openclaw_aegis_url)
-            target_custom_prompt = None
-            _dyn_db_url = get_secret("DATABASE_URL", aegis_url=_openclaw_aegis_url)
-            
-            if target_persona_id:
-                try:
-                    # [🔱 V7.0 Stateless Oracle] Use Aegis REST API instead of direct DB
-                    # _openclaw_aegis_url is already determined from headers
-                    p_data = neural_link.get_guardian_identity(target_persona_id, aegis_url=_openclaw_aegis_url)
-                    if p_data:
-                        target_display_name = p_data.get("display_name") or target_display_name
-                        target_custom_prompt = p_data.get("relay_system_prompt")
-                        logger.info(f"[OpenClaw Persona] Identity Resolved via Aegis: {target_display_name}")
-                except Exception as db_e:
-                    logger.error(f"[OpenClaw Persona] Aegis Lookup Failed: {db_e}")
-
-            # 🧬 [정체성 통일] '로컬 Shadow'(shadow_brain)는 guardian_personas.relay_system_prompt가
-            # 비어있으면 하드코딩된 "그림자 두뇌"로 새는 대신, 로컬 수호자 레지스트리 → 정체성(SOUL)에서
-            # 관리하는 LOCAL_SHADOW_SOUL.md(또는 그 DB 공통 기본값)를 그대로 따르게 한다.
-            # (/api/shadow/shadow/send 릴레이가 쓰는 것과 동일한 소스 — 두 경로가 서로 다른 자아를
-            #  말하는 걸 방지한다.)
-            if target_guardian == "shadow_brain" and not target_custom_prompt:
-                try:
-                    from guardian_soul import load_guardian_soul
-                    from local_policy_defaults import fetch_policy_defaults
-                    _soul_token = (
-                        request.headers.get("X-Imperial-Token")
-                        or request.headers.get("Authorization", "").replace("Bearer ", "")
-                    )
-                    _soul_default = fetch_policy_defaults(_openclaw_aegis_url, _soul_token).get("taemini_soul", "")
-                    soul_result = load_guardian_soul("taemini", server_default=_soul_default)
-                    soul_text = (soul_result.get("content") or "").strip()
-                    if soul_text:
-                        target_custom_prompt = soul_text
-                        target_display_name = "로컬 Shadow"
-                except Exception as soul_err:
-                    logger.warning(f"[Local Shadow] SOUL 로드 실패(direct channel): {soul_err}")
-
-            # --- [🔱 V6.2 Message Parsing Restoration] ---
-            for m in messages:
-                role = m.get("role", "")
-                content = m.get("content", "")
-                
-                parts = []
-                if isinstance(content, str):
-                    parts.append(content)
-                elif isinstance(content, list):
-                    for item in content:
-                        if item.get("type") == "text":
-                            parts.append(item.get("text", ""))
-                        elif item.get("type") == "image_url":
-                            img_url_obj = item.get("image_url", {})
-                            img_url = img_url_obj.get("url", "")
-                            if img_url.startswith("data:image"):
-                                # Parse base64
-                                try:
-                                    header, b64_data = img_url.split(",", 1)
-                                    mime_type = header.split(";")[0].split(":")[1]
-                                    image_bytes = base64.b64decode(b64_data)
-                                    parts.append(types.Part.from_bytes(data=image_bytes, mime_type=mime_type))
-                                except Exception as e:
-                                    parts.append(f"[Image Decoding Error: {str(e)}]")
-                            elif img_url.startswith("http"):
-                                try:
-                                    req = requests.get(img_url, timeout=5)
-                                    if req.status_code == 200:
-                                        mime_type = req.headers.get("Content-Type", "image/jpeg")
-                                        parts.append(types.Part.from_bytes(data=req.content, mime_type=mime_type))
-                                    else:
-                                        parts.append(f"[Image DL Failed: HTTP {req.status_code}]")
-                                except Exception as e:
-                                    parts.append(f"[Image Fetch Error: {str(e)}]")
-                
-                if role == "system":
-                    for p in parts:
-                        if isinstance(p, str):
-                            system_instruction += p + "\n"
-                else:
-                    user_contents.extend(parts)
-
-            context_id = request.headers.get("X-Context-Id", "GLOBAL")
-            auth_token = request.headers.get("X-Imperial-Token") or request.headers.get("Authorization", "").replace("Bearer ", "")
-            sender_persona_uuid = "anonymous"
-            if session_key.startswith("agent:"):
-                parts = session_key.split(":")
-                if len(parts) >= 3:
-                    sender_persona_uuid = parts[2]
-            user_prompt = user_contents[0] if user_contents and isinstance(user_contents[0], str) else ""
-            history_context = _load_recent_history_context(
-                context_id,
-                token=auth_token,
-                aegis_url=_openclaw_aegis_url,
-                sender_label=sender_persona_uuid,
-                target_label=target_display_name,
-                explicit_history=messages,
-                current_prompt=user_prompt,
-            )
-
-            # Assemble Imperial Instruction
-            identity_directive = "당신은 제국의 핵심 수호자입니다."
-            final_system_instruction = _build_system_instruction(
-                target_display_name,
-                target_custom_prompt,
-                history_context,
-                identity_directive,
-                sender=sender_persona_uuid,
-                is_master=None,
-            )
-            
-            if system_instruction:
-                system_instruction = final_system_instruction + "\n\n" + system_instruction
-            else:
-                system_instruction = final_system_instruction
-
-            # 🔱 [Provider Dispatch] 로컬 Shadow도 클라우드 Shadow Brain처럼 모든 프로바이더/모델 지원
-            # provider가 google 계열이 아니면 jarvis_brain.think()로 위임한다.
-            # (Nous/Hermes/OpenRouter/OpenClaw/NVIDIA/GLM/Ollama 등 OpenAI 호환 경로 포함)
-            requested_provider = (data.get("provider") or "").strip().lower()
-            _google_like = requested_provider in ("", "google", "gemini", "copilot", "github", "vertex")
-            if jarvis_brain and requested_provider and not _google_like:
-                skip_history_save = request.headers.get("X-Skip-History-Save", "false").lower() == "true"
-                if session_key.startswith("agent:"):
-                    _sk_parts = session_key.split(":")
-                    if len(_sk_parts) >= 3:
-                        sender_persona_uuid = _sk_parts[2]
-
-                import services.chat_service as chat_service
-                think_prompt = " ".join(
-                    [p for p in user_contents if isinstance(p, str)]
-                ).strip() or "(No content provided)"
-
-                # 사용자 발화 저장 (google 경로와 동일)
-                if think_prompt and not skip_history_save:
-                    chat_service._save_chat_history(
-                        sender_persona_uuid,
-                        think_prompt,
-                        message_type=0,
-                        context_id=context_id,
-                        token=auth_token,
-                        aegis_url=_openclaw_aegis_url,
-                    )
-
-                from flask import Response, stream_with_context
+    # OpenAI-compat /v1/chat/completions → blueprints/openai_compat_routes.py
+    from blueprints.openai_compat_routes import init_openai_compat_routes
+    init_openai_compat_routes(
+        app,
+        get_jarvis_brain=lambda: getattr(app, "jarvis_brain", None) or jarvis_brain,
+        db_url=db_url,
+    )
 
-                def generate_provider_stream():
-                    chat_id = f"chatcmpl-{uuid.uuid4()}"
-                    accumulated = []
-                    try:
-                        for chunk_text in jarvis_brain.think(
-                            think_prompt,
-                            model_name=model,
-                            provider=requested_provider,
-                            system_instruction=system_instruction,
-                            session_id=context_id,
-                            token=auth_token,
-                            aegis_url=_openclaw_aegis_url,
-                            interactive=True,
-                        ):
-                            if not chunk_text:
-                                continue
-                            accumulated.append(chunk_text)
-                            sse_payload = {
-                                "id": chat_id,
-                                "object": "chat.completion.chunk",
-                                "created": int(time.time()),
-                                "model": model,
-                                "choices": [{
-                                    "index": 0,
-                                    "delta": {"content": chunk_text},
-                                    "finish_reason": None,
-                                }],
-                            }
-                            yield f"data: {json.dumps(sse_payload, ensure_ascii=False)}\n\n"
-
-                        final_payload = {
-                            "id": chat_id,
-                            "object": "chat.completion.chunk",
-                            "created": int(time.time()),
-                            "model": model,
-                            "choices": [{
-                                "index": 0,
-                                "delta": {},
-                                "finish_reason": "stop",
-                            }],
-                        }
-                        yield f"data: {json.dumps(final_payload, ensure_ascii=False)}\n\n"
-                        yield "data: [DONE]\n\n"
-
-                        full_reply = "".join(accumulated)
-                        if full_reply and not skip_history_save:
-                            _emo = _extract_emotion_from_text(full_reply)
-                            chat_service._save_chat_history(
-                                target_persona_id,
-                                full_reply,
-                                message_type=1,
-                                context_id=context_id,
-                                emotion=_emo,
-                                token=auth_token,
-                                aegis_url=_openclaw_aegis_url,
-                            )
-                            # WebSocket 브로드캐스트도 skip이면 생략한다. skip=로컬 전용이면
-                            # 요청한 클라이언트가 이미 스트리밍으로 응답을 받았으므로, 푸시하면
-                            # 같은 답이 한 번 더 버블로 떠 화면에 2개로 보인다(재접속하면 1개).
-                            try:
-                                from blueprints.chat_routes import session_manager
-                                now_utc_str = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
-                                session_manager.broadcast_chat({
-                                    "id": f"chatmsg-{uuid.uuid4()}",
-                                    "text": _strip_emotion_tags(full_reply),
-                                    "type": 1,
-                                    "relayGuardian": target_guardian,
-                                    "senderId": target_persona_id,
-                                    "senderName": target_display_name,
-                                    "context_id": context_id,
-                                    "emotion": _extract_emotion_from_text(full_reply),
-                                    "timestamp": now_utc_str,
-                                })
-                            except Exception as _bc_e:
-                                logger.warning(f"[Provider Dispatch] broadcast 실패: {_bc_e}")
-                    except Exception as e_stream:
-                        error_payload = {
-                            "id": f"chatcmpl-{uuid.uuid4()}",
-                            "object": "chat.completion.chunk",
-                            "created": int(time.time()),
-                            "model": model,
-                            "choices": [{
-                                "index": 0,
-                                "delta": {"content": f"\n❌ [Shadow Brain Stream Error] {str(e_stream)}"},
-                                "finish_reason": "error",
-                            }],
-                        }
-                        yield f"data: {json.dumps(error_payload, ensure_ascii=False)}\n\n"
-                        yield "data: [DONE]\n\n"
-
-                if data.get("stream", False):
-                    return Response(stream_with_context(generate_provider_stream()), mimetype='text/event-stream')
-
-                # 비스트리밍 요청: 전체 응답을 모아 OpenAI 형식으로 반환
-                full_text = "".join([
-                    c for c in jarvis_brain.think(
-                        think_prompt,
-                        model_name=model,
-                        provider=requested_provider,
-                        system_instruction=system_instruction,
-                        session_id=context_id,
-                        token=auth_token,
-                        aegis_url=_openclaw_aegis_url,
-                        interactive=True,
-                    ) if c
-                ])
-                if full_text and not skip_history_save:
-                    chat_service._save_chat_history(
-                        target_persona_id, full_text, message_type=1,
-                        context_id=context_id, token=auth_token, aegis_url=_openclaw_aegis_url,
-                    )
-                return jsonify({
-                    "id": f"chatcmpl-{uuid.uuid4()}",
-                    "object": "chat.completion",
-                    "created": int(time.time()),
-                    "model": model,
-                    "choices": [{
-                        "index": 0,
-                        "message": {"role": "assistant", "content": full_text},
-                        "finish_reason": "stop",
-                    }],
-                })
-
-            # Use specific model logic
-            actual_model = jarvis_brain._resolve_actual_model("google", model)
-            
-            client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
-            config_params = {}
-            if system_instruction:
-                config_params["system_instruction"] = system_instruction
-                
-            if not user_contents:
-                user_contents = ["(No content provided)"]
-                
-            # Get context_id if provided
-            skip_history_save = request.headers.get("X-Skip-History-Save", "false").lower() == "true"
-            
-            # Extract Sender Persona UUID from session key
-            if session_key.startswith("agent:"):
-                parts = session_key.split(":")
-                if len(parts) >= 3:
-                    sender_persona_uuid = parts[2]
-            
-            # Save user prompt first
-            import services.chat_service as chat_service
-            user_prompt = user_contents[0] if user_contents and isinstance(user_contents[0], str) else ""
-            if user_prompt and not skip_history_save:
-                chat_service._save_chat_history(
-                    sender_persona_uuid,
-                    user_prompt,
-                    message_type=0,
-                    context_id=context_id,
-                    token=auth_token,
-                    aegis_url=_openclaw_aegis_url
-                )
-                
-            stream_requested = data.get("stream", False)
-            
-            if stream_requested:
-                # 🔱 OpenAI SSE Streaming Mode Support
-                from flask import Response, stream_with_context
-                def generate_stream():
-                    try:
-                        response_stream = client.models.generate_content_stream(
-                            model=actual_model,
-                            contents=user_contents,
-                            config=types.GenerateContentConfig(**config_params)
-                        )
-                        chat_id = f"chatcmpl-{uuid.uuid4()}"
-                        accumulated = []
-                        for chunk in response_stream:
-                            chunk_text = chunk.text or ""
-                            if chunk_text:
-                                accumulated.append(chunk_text)
-                                sse_payload = {
-                                    "id": chat_id,
-                                    "object": "chat.completion.chunk",
-                                    "created": int(time.time()),
-                                    "model": model,
-                                    "choices": [{
-                                        "index": 0,
-                                        "delta": {
-                                            "content": chunk_text
-                                        },
-                                        "finish_reason": None
-                                    }]
-                                }
-                                yield f"data: {json.dumps(sse_payload, ensure_ascii=False)}\n\n"
-                        # SSE Done signal
-                        final_payload = {
-                            "id": chat_id,
-                            "object": "chat.completion.chunk",
-                            "created": int(time.time()),
-                            "model": model,
-                            "choices": [{
-                                "index": 0,
-                                "delta": {},
-                                "finish_reason": "stop"
-                            }]
-                        }
-                        yield f"data: {json.dumps(final_payload, ensure_ascii=False)}\n\n"
-                        yield "data: [DONE]\n\n"
-                        
-                        # Save AI Reply to DB and Broadcast.
-                        # skip=로컬 전용이면 저장·브로드캐스트 둘 다 생략한다(요청 클라이언트가
-                        # 이미 스트리밍으로 받았으므로 푸시하면 화면에 2개로 보임 — 재접속 시 1개).
-                        full_reply = "".join(accumulated)
-                        if full_reply and not skip_history_save:
-                            _emo = _extract_emotion_from_text(full_reply)
-                            chat_service._save_chat_history(
-                                target_persona_id,
-                                full_reply,
-                                message_type=1,
-                                context_id=context_id,
-                                emotion=_emo,
-                                token=auth_token,
-                                aegis_url=_openclaw_aegis_url
-                            )
-                            from blueprints.chat_routes import session_manager
-                            now_utc_str = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
-                            msg_uuid = f"chatmsg-{uuid.uuid4()}"
-                            session_manager.broadcast_chat({
-                                "id": msg_uuid,
-                                "text": _strip_emotion_tags(full_reply),
-                                "type": 1,
-                                "relayGuardian": target_guardian,
-                                "senderId": target_persona_id,
-                                "senderName": target_display_name,
-                                "context_id": context_id,
-                                "emotion": _emo,
-                                "timestamp": now_utc_str
-                            })
-                    except Exception as e_stream:
-                        error_payload = {
-                            "id": f"chatcmpl-{uuid.uuid4()}",
-                            "object": "chat.completion.chunk",
-                            "created": int(time.time()),
-                            "model": model,
-                            "choices": [{
-                                "index": 0,
-                                "delta": {
-                                    "content": f"\n❌ [Shadow Brain Stream Error] {str(e_stream)}"
-                                },
-                                "finish_reason": "error"
-                            }]
-                        }
-                        yield f"data: {json.dumps(error_payload, ensure_ascii=False)}\n\n"
-                        yield "data: [DONE]\n\n"
-                return Response(stream_with_context(generate_stream()), mimetype='text/event-stream')
-            
-            else:
-                response = client.models.generate_content(
-                    model=actual_model,
-                    contents=user_contents,
-                    config=types.GenerateContentConfig(**config_params)
-                )
-                reply = response.text
-                if reply and not skip_history_save:
-                    _emo = _extract_emotion_from_text(reply)
-                    chat_service._save_chat_history(
-                        target_persona_id,
-                        reply,
-                        message_type=1,
-                        context_id=context_id,
-                        emotion=_emo,
-                        token=auth_token,
-                        aegis_url=_openclaw_aegis_url
-                    )
-        except Exception as e:
-            reply = f"Error from Shadow Brain AI: {str(e)}"
-            
-        return jsonify({
-            "id": f"chatcmpl-{uuid.uuid4()}",
-            "object": "chat.completion",
-            "created": int(time.time()),
-            "model": model,
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": reply
-                },
-                "finish_reason": "stop"
-            }],
-            "usage": {
-                "prompt_tokens": len(str(user_contents)) // 4,
-                "completion_tokens": len(reply) // 4,
-                "total_tokens": (len(str(user_contents)) + len(reply)) // 4
-            }
-        })
 
     @app.route('/os_assets/<path:filename>')
     def serve_os_assets(filename):
@@ -1686,5885 +704,1355 @@ def create_web_server(project_root, jarvisrun_engine, cluster=None, app_instance
         return None
 
 
-    @app.route('/api/auth/login', methods=['POST', 'OPTIONS'])
-    def api_auth_login():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
+    # Auth → blueprints/local_auth_routes.py
+    from blueprints.local_auth_routes import init_local_auth_routes
+    init_local_auth_routes(app)
+
+    # # ═══════════════════════════════════════════════════════════
 
-        data = request.json or {}
-        username = (data.get('username') or '').strip()
-        password = data.get('password') or ''
-        if not username or not password:
-            return jsonify({'status': 'ERROR', 'message': '아이디와 비밀번호를 모두 입력해주세요.'}), 400
+    # HYDRA → blueprints/hydra_proxy_routes.py
+    from blueprints.hydra_proxy_routes import init_hydra_proxy_routes
+    init_hydra_proxy_routes(app)
 
+    # === Imperial Admin API (Master Only) ===
+    # # ═══════════════════════════════════════════════════════════
+
+    def _verify_imperial_token(token):
+        """🔱 [Imperial Auth Bridge] Verifies session token against Django managed table."""
+        if not token: return None
         try:
             from sovereign_memory import DB_URL
-
             conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
             cur = conn.cursor()
-            cur.execute(
-                """
-                SELECT id::text, username, display_name, role, is_active, password_hash
-                FROM taemingames.imperial_users
-                WHERE LOWER(username) = LOWER(%s)
+            cur.execute("""
+                SELECT u.id::text, u.username, u.display_name, u.role
+                FROM taemingames.imperial_sessions s
+                JOIN taemingames.imperial_users u ON s.user_id = u.id
+                WHERE s.token_hash = %s AND s.expires_at > CURRENT_TIMESTAMP AND u.is_active = TRUE
                 LIMIT 1
-                """,
-                (username,),
-            )
+            """, (_hash_session_token(token),))
             row = cur.fetchone()
-            if not row or not row[4] or not check_password_hash(row[5], password):
-                return jsonify({'status': 'ERROR', 'message': '로그인 정보가 올바르지 않습니다.'}), 401
-
-            session_token = secrets.token_urlsafe(32)
-            expires_at = datetime.now(timezone.utc) + timedelta(hours=24)
-            cur.execute(
-                """
-                INSERT INTO taemingames.imperial_sessions (user_id, token_hash, expires_at)
-                VALUES (%s, %s, %s)
-                """,
-                (row[0], _hash_session_token(session_token), expires_at),
-            )
-            user = {
-                'id': row[0],
-                'username': row[1],
-                'display_name': row[2],
-                'role': row[3],
-            }
-            return jsonify({'status': 'SUCCESS', 'token': session_token, 'user': _serialize_auth_user(user)})
+            if row:
+                return {'id': row[0], 'username': row[1], 'display_name': row[2], 'role': row[3]}
+            return None
         except Exception as e:
-            logger.error(f"[Auth] Login error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
+            logger.error(f"[Auth Bridge] Verification error: {e}")
+            return None
         finally:
-            if 'cur' in locals():
-                cur.close()
-            if 'conn' in locals():
-                conn.close()
-
-    @app.route('/api/auth/register', methods=['POST', 'OPTIONS'])
-    def api_auth_register():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        data = request.json or {}
-        username = (data.get('username') or '').strip()
-        display_name = (data.get('display_name') or '').strip()
-        password = data.get('password') or ''
-
-        if not username or not password:
-            return jsonify({'status': 'ERROR', 'message': '사용자명과 비밀번호는 필수 항목입니다.'}), 400
-        if len(password) < 8:
-            return jsonify({'status': 'ERROR', 'message': '비밀번호는 최소 8자 이상이어야 합니다.'}), 400
-        if not display_name:
-            display_name = username
+            if 'cur' in locals(): cur.close()
+            if 'conn' in locals(): conn.close()
 
-        try:
-            from sovereign_memory import DB_URL
+    def _require_master_user():
+        """🔱 [Standard Auth] Requires Master role via Django Session."""
+        if request.method == "OPTIONS": return None, (jsonify({}), 200)
+        user = _load_session_user()
+        if not user or user.get("role") != "Master":
+            return None, (jsonify({"status": "ERROR", "message": "🔱 [이지스 차단] 마스터 권한이 요구됩니다."}), 403)
+        return user, None
 
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
+    def _require_guardian_user():
+        """🔱 [Collab Auth] Requires Master or Guardian role via Django Session."""
+        if request.method == "OPTIONS": return None, (jsonify({}), 200)
+        user = _load_session_user()
+        if not user or user.get("role") not in ["Master", "Guardian"]:
+            return None, (jsonify({"status": "ERROR", "message": "🔱 [이지스 차단] 수호자(Guardian) 이상의 권한이 요구됩니다."}), 403)
+        return user, None
 
-            # 중복 확인 (username 및 display_name)
-            cur.execute(
-                "SELECT id FROM taemingames.imperial_users WHERE LOWER(username) = LOWER(%s) OR LOWER(display_name) = LOWER(%s) LIMIT 1",
-                (username, display_name),
-            )
-            if cur.fetchone():
-                return jsonify({'status': 'ERROR', 'message': '이미 사용 중인 사용자명 또는 표시이름입니다.'}), 409
+    # [REMOVED] /api/auth/login, /api/auth/register, and all /api/admin/users/* 
+    # are now exclusively handled by Django Fortress (Port 18701).
 
-            password_hash = generate_password_hash(password)
-            cur.execute(
-                """
-                INSERT INTO taemingames.imperial_users
-                    (username, display_name, role, is_active, password_hash)
-                VALUES (%s, %s, 'User', TRUE, %s)
-                RETURNING id::text, username, display_name, role
-                """,
-                (username, display_name, password_hash),
-            )
-            row = cur.fetchone()
-            user = {
-                'id': row[0],
-                'username': row[1],
-                'display_name': row[2],
-                'role': row[3],
-            }
-            return jsonify({'status': 'SUCCESS', 'message': '회원가입이 완료되었습니다.', 'user': _serialize_auth_user(user)})
-        except Exception as e:
-            logger.error(f"[Auth] Register error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals():
-                cur.close()
-            if 'conn' in locals():
-                conn.close()
+    # ═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═
+    # 🔱 Persona Management - Engine View
+    # ═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═
 
-    @app.route('/api/auth/logout', methods=['POST', 'OPTIONS'])
-    def api_auth_logout():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
+    # Persona engine → blueprints/persona_engine_routes.py
+    from blueprints.persona_engine_routes import init_persona_engine_routes
+    init_persona_engine_routes(
+        app, project_root,
+        get_jarvis_brain=lambda: getattr(app, "jarvis_brain", None) or jarvis_brain,
+        get_cluster=lambda: cluster,
+        require_master=_require_master_user,
+        require_guardian=_require_guardian_user,
+    )
 
-        session_token = _read_session_token()
-        if not session_token:
-            return jsonify({'status': 'SUCCESS'})
+    # Portrait → blueprints/portrait_routes.py
+    from blueprints.portrait_routes import init_portrait_routes
+    init_portrait_routes(app, project_root)
 
-        try:
-            from sovereign_memory import DB_URL
+    # --- R2 Multi-Account API → blueprints/r2_routes.py ---
+    from blueprints.r2_routes import init_r2_routes
+    init_r2_routes(app, project_root, require_imperial_auth=_require_imperial_auth)
 
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-            cur.execute(
-                "DELETE FROM taemingames.imperial_sessions WHERE token_hash = %s",
-                (_hash_session_token(session_token),),
-            )
-            return jsonify({'status': 'SUCCESS'})
-        except Exception as e:
-            logger.error(f"[Auth] Logout error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals():
-                cur.close()
-            if 'conn' in locals():
-                conn.close()
+    # --- Guardian Summoning & Purification API ---
 
-    @app.route('/api/auth/me', methods=['GET', 'OPTIONS'])
-    def api_auth_me():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
+    # Summon/purify → blueprints/summon_routes.py
+    from blueprints.summon_routes import init_summon_routes
+    init_summon_routes(app, project_root, require_imperial=_require_imperial_auth)
 
-        user, auth_error = _require_session_user()
-        if auth_error:
-            return auth_error
-        return jsonify({'status': 'SUCCESS', 'user': _serialize_auth_user(user)})
+    # Cluster → blueprints/cluster_routes.py
+    from blueprints.cluster_routes import init_cluster_routes
+    init_cluster_routes(app, get_cluster=lambda: cluster)
 
-    @app.route('/api/auth/profile', methods=['PUT', 'OPTIONS'])
-    def api_auth_profile():
+    @app.route('/api/shadow/telegram/chat', methods=['POST', 'OPTIONS'])
+    def telegram_relay_chat():
+        """이지스 텔레그램 릴레이가 메시지를 전달하면 현재 설정 provider/model로 응답을 생성해 반환한다."""
         if request.method == 'OPTIONS':
             return jsonify({}), 200
-
-        user, auth_error = _require_session_user()
-        if auth_error:
-            return auth_error
-
-        data = request.json or {}
-        new_display = (data.get('display_name') or '').strip()
-        if not new_display:
-            return jsonify({'status': 'ERROR', 'message': '표시이름을 입력해주세요.'}), 400
-
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-            # 중복 확인 (본인 제외)
-            cur.execute(
-                "SELECT id FROM taemingames.imperial_users WHERE LOWER(display_name) = LOWER(%s) AND id != %s LIMIT 1",
-                (new_display, user['id']),
-            )
-            if cur.fetchone():
-                return jsonify({'status': 'ERROR', 'message': '이미 사용 중인 표시이름입니다.'}), 409
-            cur.execute(
-                "UPDATE taemingames.imperial_users SET display_name = %s, updated_at = CURRENT_TIMESTAMP WHERE id = %s",
-                (new_display, user['id']),
-            )
-            return jsonify({'status': 'SUCCESS', 'message': '표시이름이 변경되었습니다.', 'display_name': new_display})
-        except Exception as e:
-            logger.error(f"[Auth] Profile update error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    @app.route('/api/auth/password', methods=['PUT', 'OPTIONS'])
-    def api_auth_password():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        user, auth_error = _require_session_user()
-        if auth_error:
-            return auth_error
-
-        data = request.json or {}
-        current_pw = data.get('current_password') or ''
-        new_pw = data.get('new_password') or ''
-        if not current_pw or not new_pw:
-            return jsonify({'status': 'ERROR', 'message': '현재 비밀번호와 새 비밀번호를 모두 입력해주세요.'}), 400
-        if len(new_pw) < 8:
-            return jsonify({'status': 'ERROR', 'message': '새 비밀번호는 최소 8자 이상이어야 합니다.'}), 400
-
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-            cur.execute(
-                "SELECT password_hash FROM taemingames.imperial_users WHERE id = %s",
-                (user['id'],),
-            )
-            row = cur.fetchone()
-            if not row or not check_password_hash(row[0], current_pw):
-                return jsonify({'status': 'ERROR', 'message': '현재 비밀번호가 올바르지 않습니다.'}), 401
-            cur.execute(
-                "UPDATE taemingames.imperial_users SET password_hash = %s, updated_at = CURRENT_TIMESTAMP WHERE id = %s",
-                (generate_password_hash(new_pw), user['id']),
-            )
-            return jsonify({'status': 'SUCCESS', 'message': '비밀번호가 변경되었습니다.'})
-        except Exception as e:
-            logger.error(f"[Auth] Password change error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    # # ═══════════════════════════════════════════════════════════
-
-    @app.route('/api/hydra/mission', methods=['POST', 'OPTIONS'])
-    def api_hydra_mission():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        # auth is usually required, but since this is internal bridging from Django Aegis, we might just allow it or use service token
-        data = request.json or {}
-        command = data.get('command')
-        task_id = data.get('task_id')
-
-        if not command or not task_id:
-            return jsonify({"status": "ERROR", "message": "command and task_id required"}), 400
-
-        try:
-            import threading
-            from engines.hydra import hydra_director
-            t = threading.Thread(target=hydra_director.execute_parallel_planning, args=(command, task_id))
-            t.daemon = True
-            t.start()
-            return jsonify({"status": "SUCCESS", "message": "HYDRA Parallel Planning Started."}), 200
-        except Exception as e:
-            logger.error(f"[HYDRA API] {e}")
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-    # === Imperial Admin API (Master Only) ===
-    # # ═══════════════════════════════════════════════════════════
-
-    def _verify_imperial_token(token):
-        """🔱 [Imperial Auth Bridge] Verifies session token against Django managed table."""
-        if not token: return None
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            cur = conn.cursor()
-            cur.execute("""
-                SELECT u.id::text, u.username, u.display_name, u.role
-                FROM taemingames.imperial_sessions s
-                JOIN taemingames.imperial_users u ON s.user_id = u.id
-                WHERE s.token_hash = %s AND s.expires_at > CURRENT_TIMESTAMP AND u.is_active = TRUE
-                LIMIT 1
-            """, (_hash_session_token(token),))
-            row = cur.fetchone()
-            if row:
-                return {'id': row[0], 'username': row[1], 'display_name': row[2], 'role': row[3]}
-            return None
-        except Exception as e:
-            logger.error(f"[Auth Bridge] Verification error: {e}")
-            return None
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    def _require_master_user():
-        """🔱 [Standard Auth] Requires Master role via Django Session."""
-        if request.method == "OPTIONS": return None, (jsonify({}), 200)
-        user = _load_session_user()
-        if not user or user.get("role") != "Master":
-            return None, (jsonify({"status": "ERROR", "message": "🔱 [이지스 차단] 마스터 권한이 요구됩니다."}), 403)
-        return user, None
-
-    def _require_guardian_user():
-        """🔱 [Collab Auth] Requires Master or Guardian role via Django Session."""
-        if request.method == "OPTIONS": return None, (jsonify({}), 200)
-        user = _load_session_user()
-        if not user or user.get("role") not in ["Master", "Guardian"]:
-            return None, (jsonify({"status": "ERROR", "message": "🔱 [이지스 차단] 수호자(Guardian) 이상의 권한이 요구됩니다."}), 403)
-        return user, None
-
-    # [REMOVED] /api/auth/login, /api/auth/register, and all /api/admin/users/* 
-    # are now exclusively handled by Django Fortress (Port 18701).
-
-    # ═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═
-    # 🔱 Persona Management - Engine View
-    # ═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═━═
-
-    @app.route('/api/guardians/personas', methods=['GET', 'OPTIONS'])
-    def api_guardians_get_personas():
-        """Engine view of public personas (Read-only, SSOT: taemingames)."""
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-        from sovereign_memory import DB_URL
-        # [🔱 Stateless Architecture] DB 직결이 봉인된 환경에서는 Aegis REST로 프록시합니다.
-        # (Aegis 응답에는 core_brain_id가 포함되어 헤임달 식별 계약을 그대로 충족)
-        if not DB_URL:
-            try:
-                import requests as _requests
-                aegis_base = (request.headers.get("X-Aegis-URL")
-                              or os.environ.get("SHADOW_CLOUD_URL")
-                              or "http://127.0.0.1:18701").rstrip("/")
-                headers = {}
-                auth = request.headers.get("Authorization")
-                if auth:
-                    headers["Authorization"] = auth
-                resp = _requests.get(f"{aegis_base}/api/guardians/personas", headers=headers, timeout=8)
-                return jsonify(resp.json()), resp.status_code
-            except Exception as proxy_err:
-                logger.error(f"[Guardians] Aegis personas proxy error: {proxy_err}")
-                return jsonify({'status': 'ERROR', 'message': f'Aegis proxy failed: {proxy_err}'}), 502
-        try:
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-            cur.execute("""
-                SELECT p.id, p.name, p.profile_image_url, p.theme_color, p.voice_model,
-                       p.role, p.description, p.email, t.display_name as team, p.canonical_name, p.aliases,
-                       p.gender, p.voice_engine, p.portrait_prompt_hint, p.negative_prompt_hint,
-                       p.casting_mode, p.capabilities, p.emotions
-                FROM taemingames.guardian_personas p
-                LEFT JOIN taemingames.imperial_teams t ON p.team_id = t.id
-                WHERE p.canonical_name NOT IN ('aegis', 'gilgamesh')
-                ORDER BY p.name ASC
-            """)
-            personas = []
-            for r in cur.fetchall():
-                p_url = r[2]
-                # Dynamic Resolution: Prepend R2 root if relative path
-                p_url = resolve_imperial_profile_url(p_url)
-                
-                # Legacy Fallback: If it's still an old API path, prepend vault (for backwards compatibility)
-                if p_url and p_url.startswith('/api/'):
-                    vault_root = R2_ACCOUNTS.get('vault', {}).get('public_url', '')
-                    p_url = f"{vault_root.rstrip('/')}/{p_url.lstrip('/')}"
-                personas.append({
-                    'id': r[0],
-                    'name': r[1],
-                    'profile_image_url': p_url,
-                    'theme_color': r[3],
-                    'voice_model': r[4],
-                    'role': r[5],
-                    'description': r[6],
-                    'email': r[7],
-                    'team': r[8],
-                    'canonical_name': r[9],
-                    'aliases': r[10] if isinstance(r[10], list) else [],
-                    'gender': r[11],
-                    'voice_engine': r[12],
-                    'portrait_prompt_hint': r[13],
-                    'negative_prompt_hint': r[14],
-                    'casting_mode': r[15],
-                    'capabilities': r[16] if isinstance(r[16], list) else [],
-                    'emotions': r[17] if len(r) > 17 and r[17] else {}
-                })
-            # [🔱 Dynamic Identity] 헤임달이 로컬 모드에서도 쉐도우 브레인을 식별할 수 있도록
-            # core_brain_id를 함께 내려줍니다. (장고 /guardians/personas 응답과 동일 계약)
-            core_brain_id = None
-            try:
-                from sovereign_memory import get_secret
-                core_brain_id = get_secret("SHADOW_BRAIN_PERSONA_ID")
-            except Exception as id_err:
-                logger.warning(f"[Guardians] SHADOW_BRAIN_PERSONA_ID lookup failed: {id_err}")
-            if not core_brain_id:
-                for p in personas:
-                    cname = (p.get('canonical_name') or '').lower()
-                    pname = (p.get('name') or '')
-                    aliases = [str(a).lower() for a in (p.get('aliases') or [])]
-                    is_rust = '러스트' in pname or 'rust' in pname.lower() or '러스트' in cname
-                    if is_rust:
-                        continue
-                    if (cname in ('그림자 두뇌', '쉐도우 브레인') or
-                            pname in ('그림자 두뇌', '쉐도우 브레인') or
-                            'shadow_brain' in aliases or 'shadowbrain' in aliases or
-                            cname == 'shadow_brain'):
-                        core_brain_id = str(p['id'])
-                        break
-            return jsonify({'status': 'SUCCESS', 'core_brain_id': core_brain_id, 'personas': personas})
-        except Exception as e:
-            logger.error(f"[Guardians] Get personas error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    @app.route('/api/admin/personas', methods=['GET', 'OPTIONS'])
-    def api_admin_get_personas():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        admin, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-            cur.execute("""
-                SELECT p.id, p.name, p.profile_image_url, p.theme_color, p.voice_model, 
-                       p.role, p.description, p.email, t.display_name as team, p.canonical_name, p.aliases, 
-                       p.gender, p.voice_engine, p.portrait_prompt_hint, p.negative_prompt_hint, p.casting_mode, p.capabilities,
-                       p.emotions,
-                       array_remove(array_agg(u.username), NULL) as linked_users
-                FROM taemingames.guardian_personas p
-                LEFT JOIN taemingames.imperial_teams t ON p.team_id = t.id
-                LEFT JOIN taemingames.imperial_users u ON u.active_persona_id = p.id
-                WHERE p.canonical_name NOT IN ('aegis', 'gilgamesh')
-                GROUP BY p.id, t.display_name
-                ORDER BY p.name ASC
-            """)
-            personas = []
-            for r in cur.fetchall():
-                p_url = r[2]
-                # Dynamic Resolution: Prepend R2 root if relative path
-                p_url = resolve_imperial_profile_url(p_url)
-                
-                # Legacy Fallback: If it's still an old API path, prepend vault (for backwards compatibility)
-                if p_url and p_url.startswith('/api/'):
-                    from cloud_tool import R2_ACCOUNTS
-                    vault_root = R2_ACCOUNTS.get('vault', {}).get('public_url', '')
-                    p_url = f"{vault_root.rstrip('/')}/{p_url.lstrip('/')}"
-                
-                base_aliases = r[10] if isinstance(r[10], list) else (json.loads(r[10]) if isinstance(r[10], str) else [])
-                linked_users = r[17] if len(r) > 17 and isinstance(r[17], list) else []
-                # Inject linked user names (like 'shadowbrain') into aliases so frontend can resolve them
-                for lu in linked_users:
-                    if lu and lu not in base_aliases:
-                        base_aliases.append(lu)
-
-                personas.append({
-                    "id": r[0],
-                    "name": r[1],
-                    "profile_image_url": p_url,
-                    "theme_color": r[3],
-                    "voice_model": r[4],
-                    "role": r[5],
-                    "description": r[6],
-                    "email": r[7],
-                    "team": r[8],
-                    "canonical_name": r[9],
-                    "aliases": base_aliases,
-                    "gender": r[11],
-                    "voice_engine": r[12],
-                    "portrait_prompt_hint": r[13],
-                    "negative_prompt_hint": r[14],
-                    "casting_mode": r[15],
-                    "capabilities": r[16] if isinstance(r[16], list) else (json.loads(r[16]) if isinstance(r[16], str) else []),
-                    "emotions": r[17] if r[17] else {},
-                    "linked_users": linked_users
-                })
-            return jsonify({'status': 'SUCCESS', 'personas': personas})
-        except Exception as e:
-            logger.error(f"[Admin] Get personas error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    @app.route('/api/admin/personas', methods=['POST', 'OPTIONS'])
-    def api_admin_create_persona():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        _, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        try:
-            data = request.json or {}
-            name = data.get('name', '').strip()
-            if not name:
-                return jsonify({'status': 'ERROR', 'message': '이름은 필수 항목입니다.'}), 400
-
-            from sovereign_memory import DB_URL
-            import uuid
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-
-            new_id = str(uuid.uuid4())
-            cur.execute("""
-                INSERT INTO taemingames.guardian_personas (
-                    id, name, role, description, email, team_id, canonical_name, aliases, 
-                    theme_color, voice_model, voice_engine, gender, portrait_prompt_hint, 
-                    negative_prompt_hint, casting_mode, capabilities, created_at, updated_at
-                ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, NOW(), NOW())
-                RETURNING id::text
-            """, (
-                new_id, name, data.get('role'), data.get('description'), 
-                data.get('email'), data.get('team_id') or data.get('team') or data.get('guild'), data.get('canonical_name'), 
-                json.dumps(data.get('aliases', [])), data.get('theme_color'), 
-                data.get('voice_model'), data.get('voice_engine'), data.get('gender'),
-                data.get('portrait_prompt_hint'), data.get('negative_prompt_hint'),
-                data.get('casting_mode'), json.dumps(data.get('capabilities', []))
-            ))
-            
-            created_id = cur.fetchone()[0]
-            return jsonify({'status': 'SUCCESS', 'message': '수호자 페르소나가 생성되었습니다.', 'id': created_id})
-        except Exception as e:
-            logger.error(f"[Admin] Create persona error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    @app.route('/api/admin/personas/<persona_id>', methods=['PUT', 'OPTIONS'])
-    def api_admin_update_persona_full(persona_id):
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        _, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        try:
-            data = request.json or {}
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-
-            updates = []
-            params = []
-            
-            if 'guild' in data and 'team_id' not in data:
-                data['team_id'] = data['guild']
-
-            fields = [
-                'name', 'role', 'description', 'email', 'team_id', 'canonical_name', 
-                'theme_color', 'voice_model', 'voice_engine', 'gender', 
-                'profile_image_url', 'portrait_prompt_hint', 'negative_prompt_hint', 'casting_mode'
-            ]
-            
-            for field in fields:
-                if field in data:
-                    updates.append(f"{field} = %s")
-                    params.append(data[field])
-
-            if 'aliases' in data:
-                updates.append("aliases = %s")
-                params.append(json.dumps(data['aliases']))
-            
-            if 'capabilities' in data:
-                updates.append("capabilities = %s")
-                params.append(json.dumps(data['capabilities']))
-
-            if not updates:
-                return jsonify({'status': 'ERROR', 'message': '변경할 데이터가 없습니다.'}), 400
-
-            updates.append("updated_at = NOW()")
-            params.append(persona_id)
-
-            query = f"UPDATE taemingames.guardian_personas SET {', '.join(updates)} WHERE id::text = %s RETURNING id::text"
-            cur.execute(query, tuple(params))
-            
-            if not cur.fetchone():
-                return jsonify({'status': 'ERROR', 'message': '페르소나를 찾을 수 없습니다.'}), 404
-
-            return jsonify({'status': 'SUCCESS', 'message': '수호자 페르소나가 수정되었습니다.'})
-        except Exception as e:
-            logger.error(f"[Admin] Update persona error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    @app.route('/api/admin/personas/<persona_id>', methods=['DELETE', 'OPTIONS'])
-    def api_admin_delete_persona(persona_id):
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        _, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-
-            cur.execute("DELETE FROM taemingames.guardian_personas WHERE id::text = %s RETURNING id::text", (persona_id,))
-            if not cur.fetchone():
-                return jsonify({'status': 'ERROR', 'message': '페르소나를 찾을 수 없습니다.'}), 404
-
-            return jsonify({'status': 'SUCCESS', 'message': '수호자 페르소나가 삭제되었습니다.'})
-        except Exception as e:
-            logger.error(f"[Admin] Delete persona error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    @app.route('/api/admin/personas/generate', methods=['POST', 'OPTIONS'])
-    def api_admin_generate_persona():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        _, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        try:
-            # Shadow Brain (JarvisBrain)을 사용하여 새로운 수호자 페르소나 생성
-            import random
-            seed = random.randint(1, 999999)
-            
-            prompt = f"""
-            [SEED: {seed}]
-            제국(Imperial) 세계관에 어울리는 완전히 새롭고 예측 불가한 AI 수호자(Guardian) 페르소나를 생성하라.
-            기존의 전범위적 틀 (단순 보안, 관리 등)을 탈피하여 매번 매우 독창적인 컨셉(SF, 양자 물리, 고대 생물 모티프, 이질적인 별빛, 자연의 마법 등 무작위 테마)에서 하나를 골라 그것을 극대화하라.
-            
-            다음 필드들을 포함한 JSON 형식으로 응답해.
-            {{
-              "name": "수호자 이름 (짧고, 독창적이며 비범)",
-              "role": "구체적이고 이색적인 역할 (예: 양자 시공간 기록관, 자연의 메아리 독해가 등)",
-              "description": "수호자에 대한 상세 설명 (배경, 성격, 기원, 독특한 유형과 특징 포함)",
-              "team": "소속 �� (Aegis, Intel, Logistics, Command, Avalon, Tartarus 중 어울리는 것)",
-              "canonical_name": "영문 식별명(영문의 라틴어 가명처럼 이름과 매칭되게)",
-              "theme_color": "대표 색상 코드 (컨셉에 완벽히 어울리는 고유 색상)",
-              "gender": "male, female 중 랜덤으로 선택",
-              "portrait_prompt_hint": "이미지 생성을 위한 영문 외양 묘사 (사이버펑크/고딕 이미지가 담긴 제국적이고 매우 구체적이며 세밀하게 표현)",
-              "capabilities": ["독창적이며 구체적인 능력 1", "능력 2", "능력 3"]
-            }}
-            응답에 반드시 순수 JSON 데이터만 포함해야 하며, 마크다운 코드 블록(```json 등)은 제외하고 오직 중괄호로 시작하는 JSON 객체를 반환해.
-            """
-            
-            # jarvis_brain.think는 제너레이터이므로 모아서 처리
-            full_response = ""
-            for chunk in jarvis_brain.think(prompt, system_instruction="You are the Imperial Soul Creator. Output ONLY valid raw JSON."):
-                full_response += chunk
-            
-            # JSON 파싱 (마크다운 가드 제거 시도)
-            clean_json = full_response.replace("```json", "").replace("```", "").strip()
-            persona_data = json.loads(clean_json) 
-            
-            return jsonify({
-                'status': 'SUCCESS',
-                'persona': persona_data
-            })
-        except Exception as e:
-            logger.error(f"[Admin] Generate persona error: {e}")
-            # fall back to a manual cleaning if json.loads fails
-            try:
-                import re
-                match = re.search(r'\{.*\}', full_response, re.DOTALL)
-                if match:
-                    persona_data = json.loads(match.group(0))
-                    return jsonify({
-                        'status': 'SUCCESS',
-                        'persona': persona_data
-                    })
-            except:
-                pass
-            return jsonify({'status': 'ERROR', 'message': f"페르소나 생성 실패: {str(e)}", "raw": full_response}), 500
-
-    @app.route('/api/admin/users/<user_id>/persona', methods=['PATCH', 'OPTIONS'])
-    def api_admin_update_user_persona(user_id):
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        admin, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        data = request.json or {}
-        active_persona_id = data.get('active_persona_id')
-
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-
-            if active_persona_id is not None:
-                cur.execute("SELECT id FROM taemingames.guardian_personas WHERE id = %s", (active_persona_id,))
-                if not cur.fetchone():
-                    return jsonify({'status': 'ERROR', 'message': '페르소나를 찾을 수 없습니다.'}), 404
-
-            cur.execute(
-                "UPDATE taemingames.imperial_users SET active_persona_id = %s WHERE id = %s RETURNING id::text",
-                (active_persona_id, user_id)
-            )
-            if not cur.fetchone():
-                return jsonify({'status': 'ERROR', 'message': '사용자를 찾을 수 없습니다.'}), 404
-
-            return jsonify({'status': 'SUCCESS', 'message': '페르소나가 업데이트 되었습니다.'})
-        except Exception as e:
-            logger.error(f"[Admin] Update persona error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    # ════════════════════════════════════════════════════════════════
-    # 🔱 Guardian Service Token Management (Master Only)
-    # ════════════════════════════════════════════════════════════════
-
-    @app.route('/api/admin/users/<user_id>/tokens', methods=['GET', 'POST', 'OPTIONS'])
-    def api_admin_service_tokens(user_id):
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        _, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-
-            if request.method == 'GET':
-                cur.execute("""
-                    SELECT id::text, name, created_at, last_used_at, expires_at, is_active
-                    FROM taemingames.guardian_service_tokens
-                    WHERE user_id = %s
-                    ORDER BY created_at DESC
-                """, (user_id,))
-                tokens = []
-                for r in cur.fetchall():
-                    tokens.append({
-                        "id": r[0],
-                        "name": r[1],
-                        "created_at": r[2].strftime("%Y-%m-%dT%H:%M:%S.000Z") if r[2] else None,
-                        "last_used_at": r[3].strftime("%Y-%m-%dT%H:%M:%S.000Z") if r[3] else None,
-                        "expires_at": r[4].strftime("%Y-%m-%dT%H:%M:%S.000Z") if r[4] else None,
-                        "is_active": r[5],
-                    })
-                return jsonify({"status": "SUCCESS", "tokens": tokens})
-
-            elif request.method == 'POST':
-                data = request.json or {}
-                name = (data.get('name') or '').strip()
-                if not name:
-                    return jsonify({'status': 'ERROR', 'message': '토큰 이름을 입력해 주세요.'}), 400
-
-                # 사용자 존재 확인
-                cur.execute("SELECT id FROM taemingames.imperial_users WHERE id = %s", (user_id,))
-                if not cur.fetchone():
-                    return jsonify({'status': 'ERROR', 'message': '사용자를 찾을 수 없습니다.'}), 404
-
-                import secrets
-                raw_token = secrets.token_urlsafe(32)
-                token_hash = _hash_session_token(raw_token)
-
-                cur.execute("""
-                    INSERT INTO taemingames.guardian_service_tokens (user_id, token_hash, name)
-                    VALUES (%s, %s, %s)
-                    RETURNING id::text
-                """, (user_id, token_hash, name))
-                token_id = cur.fetchone()[0]
-
-                return jsonify({
-                    'status': 'SUCCESS',
-                    'token_id': token_id,
-                    'token': raw_token,
-                    'message': '🛡️ [황실 보안] 서비스 토큰이 갱신되었습니다. 지금 복사 하세요.'
-                })
-
-        except Exception as e:
-            logger.error(f"[Admin] Service token error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    @app.route('/api/admin/tokens/<token_id>', methods=['PUT', 'DELETE', 'OPTIONS'])
-    def api_admin_manage_token(token_id):
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        _, auth_error = _require_master_user()
-        if auth_error:
-            return auth_error
-
-        try:
-            from sovereign_memory import DB_URL
-            conn = psycopg2.connect(DB_URL)
-            conn.autocommit = True
-            cur = conn.cursor()
-
-            if request.method == 'PUT':
-                data = request.json or {}
-                is_active = data.get('is_active')
-                if is_active is None:
-                    return jsonify({'status': 'ERROR', 'message': 'is_active 값을 지정해 주세요.'}), 400
-                cur.execute(
-                    "UPDATE taemingames.guardian_service_tokens SET is_active = %s WHERE id = %s RETURNING id::text",
-                    (bool(is_active), token_id),
-                )
-                if not cur.fetchone():
-                    return jsonify({'status': 'ERROR', 'message': '토큰을 찾을 수 없습니다.'}), 404
-                state = "활성화" if is_active else "비활성화"
-                return jsonify({'status': 'SUCCESS', 'message': f'서비스 토큰이 {state}되었습니다.'})
-
-            elif request.method == 'DELETE':
-                cur.execute(
-                    "DELETE FROM taemingames.guardian_service_tokens WHERE id = %s RETURNING id::text",
-                    (token_id,),
-                )
-                if not cur.fetchone():
-                    return jsonify({'status': 'ERROR', 'message': '토큰을 찾을 수 없습니다.'}), 404
-                return jsonify({'status': 'SUCCESS', 'message': '토큰이 영구 폐기되었습니다.'})
-
-        except Exception as e:
-            logger.error(f"[Admin] Token management error: {e}")
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-        finally:
-            if 'cur' in locals(): cur.close()
-            if 'conn' in locals(): conn.close()
-
-    def _process_concatenation_logic(audio_chunks, output_format="mp3"):
-        """🔱 [Imperial Core] Decodes multiple audio chunks into PCM and re-encodes into a single file."""
-        import subprocess
-        combined_pcm = b""
-        for chunk_data in audio_chunks:
-            try:
-                proc = subprocess.run(
-                    ['ffmpeg', '-y', '-i', 'pipe:0', '-f', 's16le', '-acodec', 'pcm_s16le', '-ac', '1', '-ar', '24000', 'pipe:1'],
-                    input=chunk_data, capture_output=True, timeout=30
-                )
-                if proc.returncode == 0: combined_pcm += proc.stdout
-            except: pass
-            
-        if not combined_pcm:
-            return None, "오디오 디코딩 실패"
-            
-        if output_format == "mp3":
-            proc = subprocess.run(
-                ['ffmpeg', '-y', '-f', 's16le', '-ar', '24000', '-ac', '1', '-i', 'pipe:0', '-f', 'mp3', 'pipe:1'],
-                input=combined_pcm, capture_output=True, timeout=600
-            )
-            return (proc.stdout, "audio/mpeg") if proc.returncode == 0 else (None, "MP3 변환 실패")
-        else:
-            proc = subprocess.run(
-                ['ffmpeg', '-y', '-f', 's16le', '-ar', '24000', '-ac', '1', '-i', 'pipe:0', '-f', 'wav', 'pipe:1'],
-                input=combined_pcm, capture_output=True, timeout=600
-            )
-            return (proc.stdout, "audio/wav") if proc.returncode == 0 else (None, "WAV 변환 실패")
-
-    def _process_orpheus_tts_logic(segments, voice_map=None, output_format="mp3"):
-        """
-        [Imperial Core] Reusable logic for high-speed Orpheus (Qwen3-TTS) generation.
-        Includes segment splitting (200 chars), same-speaker merging, disk caching (.audio),
-        multi-chunk PCM decoding (ffmpeg), and final export.
-        """
-        # 1. Merge consecutive same-speaker segments
-        merged_segments = []
-        for seg in segments:
-            seg_text = seg["text"].strip()
-            speaker = seg.get("speaker", "default").strip()
-            if merged_segments and merged_segments[-1]["speaker"] == speaker:
-                merged_segments[-1]["text"] += " " + seg_text
-            else:
-                merged_segments.append({"speaker": speaker, "text": seg_text})
-        
-        # 2. Split only excessively long segments (200+ chars) for stability
-        import re as _re
-        final_segments = []
-        for seg in merged_segments:
-            seg_text = seg["text"].strip()
-            speaker = seg["speaker"]
-            if len(seg_text) > 200:
-                sentences = _re.split(r'(?<=[.!?。！？])\s*', seg_text)
-                buf = ""
-                for sent in sentences:
-                    sent = sent.strip()
-                    if not sent: continue
-                    if buf and len(buf) + len(sent) + 1 > 200:
-                        final_segments.append({"speaker": speaker, "text": buf})
-                        buf = sent
-                    else:
-                        buf = (buf + " " + sent).strip() if buf else sent
-                if buf: final_segments.append({"speaker": speaker, "text": buf})
-            else:
-                final_segments.append({"speaker": speaker, "text": seg_text})
-        
-        # 3. Process segments with Caching
-        import hashlib
-        import requests
-        
-        combined_audio_chunks = []
-        # [🔱 Imperial Fleet Routing] Use cluster logic for dynamic routing
-        orpheus_url = cluster.get_orpheus_url() if cluster else os.environ.get("ORPHEUS_URL", "http://127.0.0.1:18800").rstrip("/")
-        
-        cache_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cache", "tts_orpheus")
-        os.makedirs(cache_dir, exist_ok=True)
-        
-        for idx, seg in enumerate(final_segments):
-            speaker = seg["speaker"]
-            seg_text = seg["text"]
-            seg_voice = voice_map.get(speaker, speaker) if voice_map else speaker
-            
-            hash_key = hashlib.md5(f"v3_{seg_voice}_{seg_text}".encode('utf-8')).hexdigest()
-            cache_filepath = os.path.join(cache_dir, f"{hash_key}.audio")
-            
-            if os.path.exists(cache_filepath):
-                with open(cache_filepath, "rb") as f:
-                    combined_audio_chunks.append(f.read())
-            else:
-                try:
-                    payload = {"text": seg_text, "voice": seg_voice.lower(), "speed": 1.0}
-                    res = requests.post(f"{orpheus_url}/tts", json=payload, timeout=300)
-                    res.raise_for_status()
-                    if res.content and len(res.content) > 100:
-                        combined_audio_chunks.append(res.content)
-                        with open(cache_filepath, "wb") as f:
-                            f.write(res.content)
-                except Exception as e:
-                    logger.error(f"[Orpheus] Generation error: {e}")
-        
-        if not combined_audio_chunks:
-            return None, "오디오 생성 실패"
-            
-        return _process_concatenation_logic(combined_audio_chunks, output_format=output_format)
-
-    @app.route('/api/config/guardian_emails', methods=['GET', 'POST', 'OPTIONS'])
-    def handle_guardian_emails():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-        
-        user, err = _require_session_user()
-        if err: return err
-        
-        if user.get("role") != "Master":
-            return jsonify({"status": "ERROR", "message": "권한이 없습니다."}), 403
-            
-        if request.method == 'GET':
-            emails = load_guardian_emails()
-            return jsonify({"status": "SUCCESS", "emails": emails})
-            
-        if request.method == 'POST':
-            data = request.json or {}
-            new_emails = data.get("emails", {})
-            if save_guardian_emails(new_emails):
-                return jsonify({"status": "SUCCESS", "message": "수호자 이메일 설정이 전역 저장되었습니다."})
-            return jsonify({"status": "ERROR", "message": "저장 중 오류 발생"}), 500
-
-        try:
-
-            if request.method == 'GET':
-
-                emails = load_guardian_emails()
-
-                return jsonify(emails)
-
-            elif request.method == 'POST':
-
-                data = request.json
-
-                if not data or 'guardianId' not in data:
-
-                    return jsonify({'status': 'ERROR', 'message': 'Missing guardianId'}), 400
-
-                guardian_id = data['guardianId']
-
-                email = data.get('email', '').strip()
-
-                emails = load_guardian_emails()
-
-                if not email:
-
-                    emails.pop(guardian_id, None)  # Remove if exists, no error if not
-
-                else:
-
-                    emails[guardian_id] = email
-
-                if save_guardian_emails(emails):
-
-                    return jsonify({'status': 'SUCCESS', 'data': emails})
-
-                else:
-
-                    return jsonify({'status': 'ERROR', 'message': 'Failed to save'}), 500
-
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-
-    # --- Guardian Status Ping API (Badge polling) ---
-
-    # --- Administrative & GBB routes migrated to blueprints/admin_routes.py ---
-
-
-
-    def _guardian_portraits_dir():
-        portraits_dir = os.path.join(
-            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-            'docker_data', 'shared_workspace', 'JarvisRun', 'guardian_portraits'
-        )
-        os.makedirs(portraits_dir, exist_ok=True)
-        return portraits_dir
-
-    def _hephaestus_outputs_dir_guardian():
-        outputs_dir = os.path.join(
-            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-            'docker_data', 'wan2gp_workspace', 'outputs'
-        )
-        return os.path.abspath(outputs_dir)
-
-    def _hephaestus_output_candidates_guardian():
-        repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        candidates = [
-            os.path.join(repo_root, 'docker_data', 'wan2gp_workspace', 'outputs'),
-            os.path.join(repo_root, 'docker_data', 'wan2gp_workspace', 'outputs2'),
-            os.path.join(repo_root, 'docker_data', 'wan2gp_workspace', 'gradio_outputs'),
-            os.path.join(repo_root, 'wan2gp', 'outputs'),
-            os.path.join(repo_root, 'wan2gp', 'outputs2'),
-            os.path.join(repo_root, 'wan2gp', 'gradio_outputs'),
-        ]
-        unique_paths = []
-        seen = set()
-        for path in candidates:
-            normalized = os.path.normcase(os.path.abspath(path))
-            if normalized in seen:
-                continue
-            seen.add(normalized)
-            unique_paths.append(os.path.abspath(path))
-        return unique_paths
-
-    def _safe_guardian_slug(value):
-        text = re.sub(r'[^A-Za-z0-9가-힣-]+', '_', str(value or '')).strip('_')
-        return text[:80] or 'guardian'
-
-    def _latest_guardian_hephaestus_image(exclude_path=None):
-        images = []
-        for outputs_dir in _hephaestus_output_candidates_guardian():
-            if not os.path.isdir(outputs_dir):
-                continue
-            for root_dir, _, filenames in os.walk(outputs_dir):
-                for filename in filenames:
-                    if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
-                        continue
-                    file_path = os.path.join(root_dir, filename)
-                    if not os.path.isfile(file_path):
-                        continue
-                    if exclude_path and os.path.normcase(os.path.abspath(file_path)) == os.path.normcase(os.path.abspath(exclude_path)):
-                        continue
-                    images.append(file_path)
-
-        if not images:
-            return None
-
-        images.sort(key=os.path.getmtime, reverse=True)
-        return images[0]
-
-    def _guardian_prompt_payload(data):
-        import random
-        name = data.get('displayName') or data.get('name') or 'guardian'
-        role = data.get('role') or 'imperial guardian'
-        desc = data.get('desc') or 'imperial guardian portrait'
-        gender = data.get('gender') or 'female'
-        prompt_hint = data.get('portraitPromptHint') or ''
-        prompt_gender = 'male' if str(gender).lower() == 'male' else 'female'
-        
-        styles = [
-            "cinematic character portrait", "hyper-realistic close-up", "epic fantasy portrait",
-            "cyberpunk character shot", "heroic character profile", "ethereal digital art",
-            "dark fantasy masterpiece", "sci-fi imperial portrait"
-        ]
-        atmospheres = [
-            "dramatic key light", "soft dream-like lighting", "neon-soaked ambience",
-            "golden hour glow", "shadowy mystery", "volumetric light beams",
-            "ethereal moonlight", "high contrast studio lighting"
-        ]
-        
-        style = random.choice(styles)
-        atmosphere = random.choice(atmospheres)
-
-        prompt = (
-            f'{style}, {prompt_gender}, {name}, {role}, '
-            f'{desc}, imperial fantasy sci-fi aesthetic, highly detailed face, sharp eyes, '
-            f'{atmosphere}, refined costume, upper body portrait, clean background, masterpiece, best quality'
-        )
-        if prompt_hint:
-            prompt = f'{prompt}, {prompt_hint}'
-        return prompt
-
-    @app.route('/api/shadow/guardian/portrait/prompt', methods=['POST'])
-    def guardian_portrait_prompt():
-        data = request.json or {}
-        latest_path = _latest_guardian_hephaestus_image()
-        guardian_id = data.get('guardianId') or data.get('relayId') or data.get('name') or 'guardian'
-        return jsonify({
-            'status': 'SUCCESS',
-            'prompt': _guardian_prompt_payload(data),
-            'filename_prefix': _safe_guardian_slug(f'{guardian_id}_{datetime.now().strftime("%Y%m%d_%H%M%S")}'),
-            'hephaestus_online': _hephaestus_online(),
-            'latest_output': os.path.basename(latest_path) if latest_path else None,
-            'has_latest_output': latest_path is not None,
-            'hephaestus_url': 'http://127.0.0.1:8001',
-            'searched_dirs': [path.replace('\\', '/') for path in _hephaestus_output_candidates_guardian()],
-        })
-
-    @app.route('/api/shadow/guardian/portrait/attach-latest', methods=['POST'])
-    def guardian_portrait_attach_latest():
-        data = request.json or {}
-        guardian_id = data.get('guardianId')
-        portrait_file = data.get('portrait_file')
-        if not guardian_id:
-            return jsonify({'status': 'ERROR', 'message': 'Missing guardianId'}), 400
-
-        latest_path = None
-        if portrait_file:
-            # generated_images 폴더에서 해당 파일 탐색
-            candidate_path = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "generated_images", portrait_file)
-            if os.path.exists(candidate_path):
-                latest_path = candidate_path
-
-        if not latest_path:
-            latest_path = _latest_guardian_hephaestus_image(exclude_path=data.get('exclude_path'))
-        if latest_path is None:
-            return jsonify({
-                'status': 'ERROR',
-                'message': 'Hephaestus 출력 이미지가 없습니다. 먼저 Hephaestus에서 이미지를 생성한 후 다시 시도해 주세요.',
-                'searched_dirs': [path.replace('\\', '/') for path in _hephaestus_output_candidates_guardian()],
-                'hephaestus_url': 'http://127.0.0.1:8001',
-            }), 404
-
-        try:
-            portraits_dir = _guardian_portraits_dir()
-            ext = os.path.splitext(latest_path)[1].lower() or '.png'
-            filename = f"{_safe_guardian_slug(guardian_id)}__{datetime.now().strftime('%Y%m%d_%H%M%S')}{ext}"
-            copied_path = os.path.join(portraits_dir, filename)
-            with open(latest_path, 'rb') as src, open(copied_path, 'wb') as dst:
-                dst.write(src.read())
-
-            # --- [Imperial Core] R2 Auto-Upload & DB Sync ---
-            # [🔱 Portrait R2 Target] 초상화는 환경(local/live) 무관하게 항상 Live(TaeminGames) 버킷의
-            # heimdall/images/portraits/ 아래에 저장한다. (기존 초상화들과 동일 위치, 어디서나 같은 공개 URL)
-            r2_url = None
-            r2_key = f"heimdall/images/portraits/{filename}"
-            rel_path = f"/images/portraits/{filename}"  # 폴백용 상대경로
-            try:
-                acc_name = "live"
-                print(f"🔱 [Imperial R2] Starting portrait upload for {filename} (Account: {acc_name}, Key: {r2_key})...")
-                uploader = ImperialR2Uploader(acc_name)
-                res = uploader.upload(copied_path, r2_key)
-                if res.get("success"):
-                    r2_url = res.get("url")
-                    print(f"🔱 [Imperial R2] Upload successful: {r2_url}")
-
-                    # --- Sync to Database (guardian_personas) with FULL R2 URL ---
-                    conn = None
-                    try:
-                        conn = get_db_connection()
-                        conn.autocommit = True
-                        cur = conn.cursor()
-                        cur.execute("""
-                            UPDATE taemingames.guardian_personas
-                            SET profile_image_url = %s, updated_at = NOW()
-                            WHERE name = %s OR id::text = %s OR canonical_name = %s
-                            RETURNING id::text
-                        """, (r2_url or rel_path, guardian_id, guardian_id, guardian_id))
-                        row = cur.fetchone()
-                        if row:
-                            print(f"🔱 [Imperial DB] Successfully synced relative portrait path to guardian_personas (ID: {row[0]})")
-                        else:
-                            print(f"⚠️ [Imperial DB] Could not find guardian '{guardian_id}' in guardian_personas to sync.")
-                        cur.close()
-                    except Exception as db_sync_err:
-                        print(f"⚠️ [Imperial DB] Failed to sync portrait path to DB: {db_sync_err}")
-                    finally:
-                        if conn:
-                            conn.close()
-                else:
-                    print(f"⚠️ [Imperial R2] Upload failed: {res.get('error')}")
-            except Exception as r2_err:
-                print(f"⚠️ [Imperial R2] Critical failure during upload/indexing: {r2_err}")
-
-            return jsonify({
-                'status': 'SUCCESS',
-                'portraitUrl': r2_url or resolve_imperial_profile_url(rel_path),
-                'portraitFile': filename,
-                'sourcePath': latest_path.replace('\\', '/'),
-                'sourceFile': os.path.basename(latest_path),
-                'r2Url': r2_url,
-                'relPath': r2_key
-            })
-        except Exception as e:
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-
-    @app.route('/api/shadow/guardian/portrait/file/<path:filename>', methods=['GET'])
-    def guardian_portrait_file(filename):
-        return send_from_directory(_guardian_portraits_dir(), filename)
-
-
-    @app.route('/api/shadow/guardian/portrait/file/<path:filename>', methods=['DELETE'])
-    def guardian_portrait_delete(filename):
-        """초상화 이미지 파일을 물리적으로 삭제합니다. (Representativie image removal is handled via DB update separately if needed)"""
-        portraits_dir = _guardian_portraits_dir()
-        file_path = os.path.join(portraits_dir, filename)
-        if not os.path.isfile(file_path):
-            return jsonify({'status': 'ERROR', 'message': '파일을 찾을 수 없습니다.'}), 404
-            
-        try:
-            os.remove(file_path)
-            return jsonify({'status': 'SUCCESS', 'message': f'초상화 {filename} 물리 삭제 완료'})
-        except Exception as e:
-            return jsonify({'status': 'ERROR', 'message': str(e)}), 500
-
-    # --- R2 Multi-Account API ---
-
-    @app.route('/api/r2/list', methods=['GET'])
-    def api_r2_list():
-        """Lists files in R2 with account isolation."""
-        account_key = request.args.get('account_id', 'vault')
-        path = request.args.get('path', '')
-        
-        try:
-            import cloud_tool
-            # R2_ACCOUNTS에서 설정 로드 (hex account_id, bucket 등 가져오기)
-            config = cloud_tool.R2_ACCOUNTS.get(account_key)
-            if not config:
-                return jsonify({"status": "ERROR", "message": f"Account {account_key} not found"}), 404
-            
-            # Access keys: Names passed from frontend (e.g. Imperial: R2_ACCESS_KEY_ID) or from config
-            access_key_name = request.args.get('access_key_name') or config.get("access_key_id")
-            secret_key_name = request.args.get('secret_key_name') or config.get("secret_access_key")
-            public_url = request.args.get('public_url') or config.get("public_url")
-            bucket = request.args.get('bucket') or config.get("bucket", "cache")
-            
-            account_config = {
-                "account_id": config.get("account_id"), # ?  hex ID (e.g. 1eeb2a8b...)
-                "access_key_id": access_key_name,
-                "secret_access_key": secret_key_name,
-                "public_url": public_url,
-                "bucket": bucket
-            }
-            
-            # cloud_tool.list_r2_files will handle BW/Env lookup for 'Imperial:...' keys
-            files = cloud_tool.list_r2_files(account_config, remote_path=path, bucket_name=bucket)
-            return jsonify({"status": "SUCCESS", "files": files})
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/r2/upload', methods=['POST'])
-    def api_r2_upload():
-        """Uploads a single file directly to R2."""
-        if 'file' not in request.files:
-            return jsonify({'status': 'ERROR', 'message': 'No file part'}), 400
-            
-        file = request.files['file']
-        if file.filename == '':
-            return jsonify({'status': 'ERROR', 'message': 'No selected file'}), 400
-            
-        account_id = request.form.get('account_id') or "1eeb2a8b871fa143f897186068eefbb5"
-        import cloud_tool
-        if account_id in cloud_tool.R2_ACCOUNTS:
-            account_id = cloud_tool.R2_ACCOUNTS[account_id].get("account_id", account_id)
-            
-        bucket = request.form.get('bucket', 'cache')
-        path_prefix = request.form.get('path', '')
-        
-        access_key_name = request.form.get('access_key_name') or "Imperial: R2_VAULT_ACCESS_KEY_ID"
-        secret_key_name = request.form.get('secret_key_name') or "Imperial: R2_VAULT_SECRET_ACCESS_KEY"
-        public_url = request.form.get('public_url', '')
-        
-        account_config = {
-            "account_id": account_id,
-            "access_key_id": access_key_name,
-            "secret_access_key": secret_key_name,
-            "public_url": public_url
-        }
-        
-        try:
-            import cloud_tool
-            import uuid
-            import os
-            from werkzeug.utils import secure_filename
-            
-            temp_dir = os.path.join(os.getcwd(), 'cache', 'temp_uploads')
-            os.makedirs(temp_dir, exist_ok=True)
-            
-            safe_filename = secure_filename(file.filename)
-            temp_path = os.path.join(temp_dir, f"{uuid.uuid4()}_{safe_filename}")
-            file.save(temp_path)
-            
-            dest_key = f"{path_prefix}/{safe_filename}" if path_prefix else safe_filename
-            dest_key = dest_key.strip('/')
-            
-            remote_path = f":s3:{bucket}/{dest_key}"
-            args = ["copyto", temp_path, remote_path]
-            result = cloud_tool.run_rclone(args, account_config)
-            
-            if not result.get("success") and "rclone not installed" in str(result.get("error")):
-                try:
-                    import boto3
-                    from cloud_tool import _get_bw_credential
-                    s3 = boto3.client(
-                        service_name='s3',
-                        endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com',
-                        aws_access_key_id=_get_bw_credential(access_key_name),
-                        aws_secret_access_key=_get_bw_credential(secret_key_name),
-                    )
-                    s3.upload_file(temp_path, bucket, dest_key)
-                    result = {"success": True}
-                except Exception as fallback_err:
-                    result = {"success": False, "error": f"Boto3 Fallback Error: {fallback_err}"}
-            
-            if os.path.exists(temp_path):
-                file_size = os.path.getsize(temp_path)
-                os.remove(temp_path)
-            else:
-                file_size = 0
-                
-            if result.get("success"):
-                # 🔱 3-Way Consistency: R2 Upload Successful -> Immediately inject PGVector to Supabase 🔱
-                conn_ins = None
-                try:
-                    import cloud_tool
-                    db_url = os.getenv("LOCAL_DATABASE_URL") or os.getenv("DB_URL")
-                    if db_url:
-                        db_url = db_url.strip('"').strip("'")
-                        conn_ins = cloud_tool.get_db_connection(db_url)
-                        cur_ins = conn_ins.cursor()
-                        cur_ins.execute("SET search_path TO taemingames, imperial_extensions, public;")
-                        raw_account_id = request.form.get('account_id') or "1eeb2a8b871fa143f897186068eefbb5"
-                        
-                        file_name = safe_filename
-                        rel_path = dest_key
-                        public_url_base = cloud_tool.R2_ACCOUNTS.get(raw_account_id, {}).get("public_url", "") if raw_account_id else ""
-                        public_url = f"{public_url_base}/{rel_path}" if public_url_base else ""
-                        
-                        ext = file_name.split('.')[-1].lower() if '.' in file_name else ''
-                        if ext in ['png','jpg','jpeg','gif','svg','webp','ico']:
-                            category = 'images'
-                        elif ext in ['pdf','doc','docx','txt','md','json','yaml']:
-                            category = 'documents'
-                        elif ext in ['mp4','webm','mov']:
-                            category = 'videos'
-                        else:
-                            category = 'misc'
-                        
-                        content_preview = f"File: {file_name} | Path: {rel_path} | Category: {category}"
-                        
-                        # Extract Gemini 3072D Embedding (Sync zero-waste operation)
-                        import sovereign_memory
-                        vector = sovereign_memory.get_embedding(content_preview)
-                        
-                        if vector:
-                            upsert_query = """
-                                INSERT INTO taemingames.r2_storage_index 
-                                (file_path, original_name, content, embedding, file_size)
-                                VALUES (%s, %s, %s, %s::vector, %s)
-                                ON CONFLICT (file_path) DO UPDATE SET
-                                content = EXCLUDED.content,
-                                embedding = EXCLUDED.embedding,
-                                file_size = EXCLUDED.file_size
-                            """
-                            cur_ins.execute(upsert_query, (
-                                rel_path, file_name, content_preview, str(vector), file_size
-                            ))
-                            conn_ins.commit()
-                            print(f"[R2 Direct Upload] DB Sync (PGVector injected) successful for: {rel_path}")
-                        cur_ins.close()
-                except Exception as db_err:
-                    print(f"[R2 Direct Upload] DB Sync failed: {db_err}")
-                finally:
-                    if conn_ins:
-                        conn_ins.close()
-                    
-                return jsonify({"status": "SUCCESS", "message": "File uploaded successfully", "path": dest_key})
-            else:
-                return jsonify({"status": "ERROR", "message": result.get("error")}), 500
-                
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/r2/download', methods=['GET'])
-    def api_r2_download():
-        """Downloads a single file from R2 to the client."""
-        account_id = request.args.get('account_id') or "1eeb2a8b871fa143f897186068eefbb5"
-        import cloud_tool
-        if account_id in cloud_tool.R2_ACCOUNTS:
-            account_id = cloud_tool.R2_ACCOUNTS[account_id].get("account_id", account_id)
-            
-        bucket = request.args.get('bucket', 'cache')
-        target_path = request.args.get('path', '')
-        
-        if not target_path:
-            return jsonify({'status': 'ERROR', 'message': 'Path is required'}), 400
-            
-        access_key_name = request.args.get('access_key_name') or "Imperial: R2_VAULT_ACCESS_KEY_ID"
-        secret_key_name = request.args.get('secret_key_name') or "Imperial: R2_VAULT_SECRET_ACCESS_KEY"
-        
-        account_config = {
-            "account_id": account_id,
-            "access_key_id": access_key_name,
-            "secret_access_key": secret_key_name,
-        }
-        
-        try:
-            import cloud_tool
-            import uuid
-            import os
-            from flask import send_file, after_this_request
-            
-            temp_dir = os.path.join(os.getcwd(), 'cache', 'temp_downloads')
-            os.makedirs(temp_dir, exist_ok=True)
-            
-            safe_filename = target_path.split('/')[-1]
-            temp_path = os.path.join(temp_dir, f"{uuid.uuid4()}_{safe_filename}")
-            
-            remote_path = f":s3:{bucket}/{target_path.strip('/')}"
-            args = ["copyto", remote_path, temp_path]
-            result = cloud_tool.run_rclone(args, account_config)
-            
-            if not result.get("success") and "rclone not installed" in str(result.get("error")):
-                try:
-                    import boto3
-                    from cloud_tool import _get_bw_credential
-                    s3 = boto3.client(
-                        service_name='s3',
-                        endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com',
-                        aws_access_key_id=_get_bw_credential(access_key_name),
-                        aws_secret_access_key=_get_bw_credential(secret_key_name),
-                    )
-                    s3.download_file(bucket, target_path.strip('/'), temp_path)
-                    result = {"success": True}
-                except Exception as fallback_err:
-                    result = {"success": False, "error": f"Boto3 Fallback Error: {fallback_err}"}
-            
-            if result.get("success") and os.path.exists(temp_path):
-                import threading
-                import time
-                def delayed_remove():
-                    time.sleep(5)  # 파일 전송 스트리밍이 완료되도록 잠시 대기 (동시성 Lock 충돌 방지)
-                    try:
-                        if os.path.exists(temp_path):
-                            os.remove(temp_path)
-                    except Exception as error:
-                        print(f"[R2 Download] Delayed Error removing temp file: {error}")
-                        
-                threading.Thread(target=delayed_remove, daemon=True).start()
-                return send_file(temp_path, as_attachment=True, download_name=safe_filename)
-            else:
-                return jsonify({"status": "ERROR", "message": result.get("error")}), 500
-                
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/r2/delete', methods=['DELETE'])
-    def api_r2_delete():
-        """Deletes a single file from R2."""
-        data = request.json or {}
-        account_id = data.get('account_id') or "1eeb2a8b871fa143f897186068eefbb5"
-        import cloud_tool
-        if account_id in cloud_tool.R2_ACCOUNTS:
-            account_id = cloud_tool.R2_ACCOUNTS[account_id].get("account_id", account_id)
-            
-        bucket = data.get('bucket', 'cache')
-        target_path = data.get('path', '')
-        
-        if not target_path:
-            return jsonify({'status': 'ERROR', 'message': 'Path is required'}), 400
-            
-        access_key_name = data.get('access_key_name') or "Imperial: R2_VAULT_ACCESS_KEY_ID"
-        secret_key_name = data.get('secret_key_name') or "Imperial: R2_VAULT_SECRET_ACCESS_KEY"
-        
-        account_config = {
-            "account_id": account_id,
-            "access_key_id": access_key_name,
-            "secret_access_key": secret_key_name,
-        }
-        
-        try:
-            import cloud_tool
-            remote_path = f":s3:{bucket}/{target_path.strip('/')}"
-            args = ["deletefile", remote_path]
-            result = cloud_tool.run_rclone(args, account_config)
-            
-            if not result.get("success") and "rclone not installed" in str(result.get("error")):
-                try:
-                    import boto3
-                    from cloud_tool import _get_bw_credential
-                    s3 = boto3.client(
-                        service_name='s3',
-                        endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com',
-                        aws_access_key_id=_get_bw_credential(access_key_name),
-                        aws_secret_access_key=_get_bw_credential(secret_key_name),
-                    )
-                    s3.delete_object(Bucket=bucket, Key=target_path.strip('/'))
-                    result = {"success": True}
-                except Exception as fallback_err:
-                    result = {"success": False, "error": f"Boto3 Fallback Error: {fallback_err}"}
-            
-            if result.get("success"):
-                # 🔱 3-Way Consistency: R2 Delete Successful -> Immediately delete DB Orphan Record 🔱
-                conn_dl = None
-                try:
-                    import cloud_tool
-                    db_url = os.getenv("LOCAL_DATABASE_URL") or os.getenv("DB_URL")
-                    if db_url:
-                        db_url = db_url.strip('"').strip("'")
-                        conn_dl = cloud_tool.get_db_connection(db_url)
-                        cur_dl = conn_dl.cursor()
-                        raw_account_id = data.get('account_id') or "1eeb2a8b871fa143f897186068eefbb5"
-                        
-                        cur_dl.execute(
-                            "DELETE FROM taemingames.r2_storage_index WHERE file_path = %s",
-                            (target_path.strip('/'),)
-                        )
-                        conn_dl.commit()
-                        deleted_count = cur_dl.rowcount
-                        cur_dl.close()
-                        print(f"[R2 Direct Delete] DB Sync (assassinated {deleted_count} orphans) successful for: {target_path}")
-                except Exception as db_err:
-                    print(f"[R2 Direct Delete] DB Sync failed: {db_err}")
-                finally:
-                    if conn_dl:
-                        conn_dl.close()
-                
-                return jsonify({"status": "SUCCESS", "message": f"File '{target_path}' deleted successfully"})
-            else:
-                return jsonify({"status": "ERROR", "message": result.get("error")}), 500
-                
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/r2/sync', methods=['POST'])
-    def api_r2_sync():
-        """Trigger smart sync between local and R2."""
-        auth_error = _require_imperial_auth()
-        if auth_error: return auth_error
-        data = request.json or {}
-        public_url = data.get('public_url')
-        account_id = data.get('account_id') or "1eeb2a8b871fa143f897186068eefbb5"
-        import cloud_tool
-        if account_id in cloud_tool.R2_ACCOUNTS:
-            account_id = cloud_tool.R2_ACCOUNTS[account_id].get("account_id", account_id)
-            
-        direction = data.get('direction', 'to_cloud')
-        bucket = data.get('bucket', 'cache')
-        
-        access_key_name = data.get('access_key_name') or "Imperial: R2_VAULT_ACCESS_KEY_ID"
-        secret_key_name = data.get('secret_key_name') or "Imperial: R2_VAULT_SECRET_ACCESS_KEY"
-        
-        account_config = {
-            "account_id": account_id,
-            "access_key_id": access_key_name,
-            "secret_access_key": secret_key_name,
-            "public_url": public_url
-        }
-        
-        def run_sync():
-            try:
-                import cloud_tool
-                print(f"[R2 Sync] Starting {direction} for {account_id} [Bucket: {bucket}]...")
-                cloud_tool.sync_r2_with_local(account_config, direction=direction, bucket_name=bucket)
-                print(f"[R2 Sync] Complete.")
-            except Exception as e:
-                import traceback
-                traceback.print_exc()
-                print(f"[R2 Sync Error] {e}")
-
-        threading.Thread(target=run_sync, daemon=True).start()
-        return jsonify({"status": "SUCCESS", "message": "동기화 작업이 백그라운드에서 시작되었습니다."})
-
-    @app.route('/api/r2/search', methods=['GET'])
-    def api_r2_search():
-        """Semantic search for R2 files via PGVector (High Precision)."""
-        query = request.args.get('q')
-        account_id = request.args.get('account_id')
-        limit = int(request.args.get('limit', 10))
-        
-        if not query:
-            return jsonify({"status": "ERROR", "message": "Query is required"}), 400
-            
-        try:
-            # [제국 통합] POST r2_semantic_search와 동일한 비밀 로직 사용
-            import importlib
-            importlib.reload(sovereign_memory)
-            
-            vector = sovereign_memory.get_query_embedding(query)
-            if not vector:
-                return jsonify({"status": "ERROR", "message": "Failed to generate query embedding"}), 500
-
-            db_url = os.getenv("LOCAL_DATABASE_URL") or os.getenv("DB_URL")
-            db_url = db_url.strip('"').strip("'")
-            
-            if "?" in db_url:
-                base_url = db_url.split("?")[0]
-                conn = psycopg2.connect(base_url)
-                cur = conn.cursor()
-                # [제국 통합] imperial_extensions와 public 모두 포함하여 일관된 검색 방식 보장
-                cur.execute("SET search_path TO taemingames, imperial_extensions, public;")
-            else:
-                conn = psycopg2.connect(db_url)
-                cur = conn.cursor()
-                cur.execute("SET search_path TO taemingames, imperial_extensions, public;")
-
-            # account_id 파라미터 추출
-            # [제국 통합] SQL 쿼리 스키마 위치에 맞춘 파라미터 순서 정렬
-            where_clause = ""
-            params = [str(vector)] # 1. Similarity
-            if account_id:
-                where_clause = "WHERE account_id = %s"
-                params.append(account_id) # 2. WHERE filter
-            params.append(str(vector)) # 3. ORDER BY
-            params.append(limit)       # 4. LIMIT
-
-            search_query = f"""
-                SELECT 
-                    id, file_path, original_name, content, file_size, updated_at,
-                    (1 - (embedding::vector <=> %s::vector)) as similarity
-                FROM taemingames.r2_storage_index
-                {where_clause}
-                ORDER BY embedding::vector <=> %s::vector
-                LIMIT %s;
-            """
-            cur.execute(search_query, tuple(params))
-            results = cur.fetchall()
-
-            cur.close()
-            conn.close()
-
-            # base URL from config
-            import cloud_tool as _ct
-            _base_pub = _ct.R2_ACCOUNTS.get('live', {}).get('public_url', '')
-
-            formatted_results = []
-            for r in results:
-                updated_at_str = r[5].strftime("%Y-%m-%dT%H:%M:%S") if r[5] else None
-                formatted_results.append({
-                    "id": r[0],
-                    "content_preview": r[3][:200] if r[3] else "",
-                    "similarity": float(r[6]),
-                    "metadata": {
-                        "filename": r[2],
-                        "path": r[1],
-                        "size": r[4] or 0,
-                        "public_url": f"{_base_pub}/{r[1]}",
-                        "ModTime": updated_at_str
-                    }
-                })
-
-            return jsonify({"status": "SUCCESS", "results": formatted_results})
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/r2/search', methods=['POST'])
-    def r2_semantic_search():
-        """R2 저장소의 파일을 의미 기반(PgVector)으로 검색합니다."""
-        try:
-            data = request.json
-            query = data.get('query', '')
-            limit = data.get('limit', 5)
-
-            if not query:
-                return jsonify({"status": "ERROR", "message": "Query is required"}), 400
-
-            # [제국 복구] sovereign_memory.py의 비밀 쿼리 사용 및 재사용
-            import importlib
-            importlib.reload(sovereign_memory)
-            
-            vector = sovereign_memory.get_query_embedding(query)
-            if not vector:
-                return jsonify({"status": "ERROR", "message": "Failed to generate query embedding"}), 500
-
-            # DB 연결 재점검 (Imperial Local Standard)
-            db_url = os.getenv("LOCAL_DATABASE_URL") or os.getenv("DB_URL")
-            if not db_url:
-                return jsonify({"status": "ERROR", "message": "LOCAL_DATABASE_URL/DB_URL not found in environment"}), 500
-
-            # [제국 수정] DSN 문자열의 따옴표 제거 (invalid dsn 오류 방지)
-            db_url = db_url.strip('"').strip("'")
-
-            # [제국 최적화] psycopg2는 URL의 'schema' 파라미터 ���식을 처리하지 못할 수 있음
-            # URL에서 쿼리 파라미터를 제거하고 순수 연결 문자열만 추출
-            if "?" in db_url:
-                base_url = db_url.split("?")[0]
-                conn = psycopg2.connect(base_url)
-                # 세션에서 스키마 설정
-                cur = conn.cursor()
-                cur.execute("SET search_path TO taemingames, public;")
-            else:
-                conn = psycopg2.connect(db_url)
-                cur = conn.cursor()
-
-            # 코사인 유사도 검색 (taemingames.r2_storage_index)
-            search_query = """
-                SELECT 
-                    id, file_path, original_name, content,
-                    (1 - (embedding <=> %s::imperial_extensions.vector)) as similarity
-                FROM taemingames.r2_storage_index
-                ORDER BY embedding <=> %s::imperial_extensions.vector
-                LIMIT %s;
-            """
-            cur.execute(search_query, (str(vector), str(vector), limit))
-            results = cur.fetchall()
-
-            cur.close()
-            conn.close()
-
-            # base URL from config
-            import cloud_tool as _ct
-            _base_pub = _ct.R2_ACCOUNTS.get('live', {}).get('public_url', '')
-
-            # 결과 포맷
-            formatted_results = []
-            for r in results:
-                formatted_results.append({
-                    "id": r[0],
-                    "file_path": r[1],
-                    "original_name": r[2],
-                    "public_url": f"{_base_pub}/{r[1]}",
-                    "content_preview": r[3][:200] if r[3] else "",
-                    "similarity": float(r[4])
-                })
-
-            return jsonify({
-                "status": "SUCCESS",
-                "results": formatted_results
-            })
-
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    # --- Guardian Summoning & Purification API ---
-
-    @app.route('/api/guardian/summon_all', methods=['POST'])
-    def api_guardian_summon_all():
-        """Triggers start-all.bat to summon all guardians."""
-        auth_error = _require_imperial_auth()
-        if auth_error: return auth_error
-        import threading
-        
-        def run_summon():
-            try:
-                summon_script = os.path.join(project_root, "scripts", "start-all.bat")
-                if os.path.exists(summon_script):
-                    print(f"[Imperial Summoner] Executing: {summon_script}")
-                    # Use start to run in a separate persistent console window on Windows
-                    subprocess.Popen(['cmd', '/c', 'start', 'cmd', '/c', summon_script], 
-                                     cwd=project_root, 
-                                     shell=True)
-            except Exception as e:
-                print(f"[Imperial Summoner] Failed to summon: {e}")
-
-        t = threading.Thread(target=run_summon, daemon=True)
-        t.start()
-        return jsonify({"status": "SUCCESS", "message": "수호자 소환 시퀀스가 가동되었습니다."}), 200
-
-    @app.route('/api/guardian/purify', methods=['POST'])
-    def api_guardian_purify():
-        """Triggers KillZombies.bat or similar to purify the system."""
-        auth_error = _require_imperial_auth()
-        if auth_error: return auth_error
-        import threading
-        
-        def run_purify():
-            try:
-                purify_script = os.path.join(project_root, "scripts", "Kill_Zombies.bat")
-                if os.path.exists(purify_script):
-                    print(f"[Imperial Purifier] Executing: {purify_script}")
-                    subprocess.Popen(['cmd', '/c', 'start', 'cmd', '/c', purify_script], 
-                                     cwd=project_root, 
-                                     shell=True)
-            except Exception as e:
-                print(f"[Imperial Purifier] Failed to purify: {e}")
-
-        t = threading.Thread(target=run_purify, daemon=True)
-        t.start()
-        return jsonify({"status": "SUCCESS", "message": "테스트 동기화 프로토콜 집행"}), 200
-
-    @app.route('/api/r2/repair', methods=['POST'])
-    def api_r2_repair():
-        """Triggers repair_r2.ps1 to recover R2 storage configuration."""
-        import threading
-        
-        def run_repair():
-            try:
-                repair_script = os.path.join(project_root, "repair_r2.ps1")
-                if os.path.exists(repair_script):
-                    print(f"[Imperial Repairer] Executing: {repair_script}")
-                    # Bitwarden session is required. Assuming the environment is already unlocked by the human master or Jarvis core.
-                    subprocess.Popen(['powershell.exe', '-File', repair_script], 
-                                     cwd=project_root, 
-                                     shell=True)
-            except Exception as e:
-                print(f"[Imperial Repairer] Failed to repair: {e}")
-
-        t = threading.Thread(target=run_repair, daemon=True)
-        t.start()
-        return jsonify({"status": "SUCCESS", "message": "황실 R2 복구 프로토콜 집행 시작"}), 200
-
-
-
-    # --- Phase 8: Imperial Fleet Cluster API ---
-
-    @app.route('/api/cluster/nodes', methods=['GET'])
-
-    def api_cluster_nodes():
-
-        if cluster:
-
-            return jsonify(cluster.get_config())
-
-        return jsonify({"nodes": {}, "allocations": {}})
-
-
-
-    @app.route('/api/cluster/allocate', methods=['POST'])
-
-    def api_cluster_allocate():
-
-        if not cluster:
-
-            return jsonify({"error": "Cluster node not initialized"}), 500
-
-        data = request.json
-
-        guardian = data.get('guardian')
-
-        target_node = data.get('node')
-
-        if not guardian or not target_node:
-
-            return jsonify({"error": "Missing parameters"}), 400
-
-            
-
-        cluster.update_allocation(guardian, target_node)
-
-        return jsonify({"status": "success"})
-
-    
-
-    @app.route('/api/cluster/register', methods=['POST'])
-
-    def api_cluster_register():
-
-        if not cluster:
-
-            return jsonify({"error": "Cluster node not initialized"}), 500
-
-        data = request.json
-
-        hostname = data.get('hostname')
-
-        if not hostname:
-
-            return jsonify({"error": "Missing hostname"}), 400
-
-            
-
-        # Update Main Node's memory state with Worker data
-
-        with cluster._lock:
-
-            cluster.active_nodes[hostname] = {
-
-                "ip": data.get('ip'),
-
-                "last_seen": data.get('last_seen', int(time.time())),
-
-                "role": data.get('role', 'WORKER'),
-
-                "allocations": data.get('allocations', {}),
-
-                "allocations_status": data.get('allocations_status', {})
-
-            }
-
-            # Also merge into allocations_status if the worker sent them
-
-            for guardian, status in data.get('allocations_status', {}).items():
-
-                cluster.active_nodes[hostname]["allocations_status"][guardian] = status
-
-                
-
-        # Trigger an immediate file sync on Main node to persist the discovered worker
-
-        cluster._sync_active_nodes_to_config()
-
-        return jsonify({"status": "success"})
-
-    
-
-    @app.route('/api/cluster/manual_peers', methods=['POST'])
-
-    def api_cluster_manual_peers():
-
-        if not cluster:
-
-            return jsonify({"error": "Cluster node not initialized"}), 500
-
-        data = request.json
-
-        ips = data.get('ips', [])
-
-        cluster.update_manual_peers(ips)
-
-        return jsonify({"status": "success"})
-
-    
-
-    # Enable hot reload for templates
-
-    app.config['TEMPLATES_AUTO_RELOAD'] = True
-
-
-
-    # --- [🔱 Imperial Telegram Relay] 이지스가 호출하는 LLM 처리 엔드포인트 ---
-    @app.route('/api/shadow/telegram/chat', methods=['POST', 'OPTIONS'])
-    def telegram_relay_chat():
-        """이지스 텔레그램 릴레이가 메시지를 전달하면 현재 설정 provider/model로 응답을 생성해 반환한다."""
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-        # Imperial Token 검증
-        token = request.headers.get('X-Imperial-Token') or request.headers.get('X-Guardian-Token')
-        expected = os.environ.get('IMPERIAL_API_TOKEN') or os.environ.get('GUARDIAN_SERVICE_TOKEN', '')
-        if expected and token != expected:
-            return jsonify({'error': 'Unauthorized'}), 401
-        data = request.get_json(force=True, silent=True) or {}
-        message = data.get('message', '')
-        user_name = data.get('user_name', '사용자')
-        user_id = data.get('user_id', '')
-        username = data.get('username', '')
-        source = data.get('source', 'unknown')
-        context_id = data.get('context_id') or f"{source}:{user_id}"
-        is_registered = data.get('is_registered', False)
-        role = data.get('role', 'guest')
-        skip_grounding = data.get('skipGrounding') is True
-        if not message:
-            return jsonify({'error': 'message required'}), 400
-        try:
-            # 🔱 [페르소나 SSOT] provider/model은 전역 JSON이 아니라 대상 수호자
-            # 페르소나(guardian_personas)에서 가져온다. think(target_persona_id=...)가
-            # Aegis /api/neural/identity 로 ai_provider/relay_model 을 해석한다.
-            # (direct/chat 과 동일한 페르소나 기반 신원 해석)
-            target_guardian = data.get('target_guardian') or 'shadow_brain'
-            aegis_url = request.headers.get('X-Aegis-URL')
-            user_display = user_name
-            if username:
-                user_display += f"(@{username})"
-            # 헤임달 가입 여부에 따라 시스템 프롬프트 차별화
-            if is_registered and role in ('Master', 'Admin'):
-                identity_line = (
-                    f"대화 상대는 제국 마왕 '{user_display}'님입니다. 헤임달 인증 계정({role})으로 확인된 최고 권위자입니다.\n"
-                    "최고의 경의와 충성으로 보좌하십시오."
-                )
-            elif is_registered:
-                identity_line = (
-                    f"대화 상대는 헤임달 인증 계정({role})을 보유한 '{user_display}'님입니다.\n"
-                    "신뢰할 수 있는 제국 구성원으로 예우하십시오."
-                )
-            else:
-                identity_line = (
-                    f"대화 상대는 '{user_display}'님이며, 현재 헤임달 미가입 외부 접속자입니다.\n"
-                    "정중하게 응대하되, 제국 내부 정보는 제한적으로 공개하십시오.\n"
-                    "반드시 응답 말미에 자연스럽게 한 번만 언급하십시오: "
-                    "헤임달에 텔레그램으로 계정을 생성하면 저와의 대화가 기억으로 연결됩니다."
-                )
-            system_instruction = (
-                f"당신은 중앙 관제 인공지능 '쉐도우브레인(ShadowBrain)'입니다.\n"
-                f"{identity_line}\n"
-                f"대화 중 자연스럽게 '{user_name}'님의 이름을 불러주십시오.\n"
-                "말투는 매우 정중하고 예의를 갖추되, 제국 사령관으로서의 권위와 압도적인 지능이 느껴져야 합니다.\n"
-                "한국어로 응답하며, 가끔 '🔱' 또는 '👑' 이모지를 섞어 제국의 위엄을 표기하십시오.\n"
-                "지시는 짧고 명확하게, 설명은 품격 있게 하십시오."
-            )
-            # 🔱 [도구 사용] 단발 호출(_call_provider) 대신 think 경로로 전환.
-            # stream=False → interactive=False 자동 적용 → 웹검색 등 도구는 돌되
-            # ask_user(선택 카드)는 자동 차단되어 텍스트로 강등된다.
-            # (헤임달 직통 채널 /api/shadow/direct/chat 은 stream=True라 영향 없음)
-            from services.brain_service import think as _think
-            _result = _think(
-                message,
-                stream=False,
-                target_persona_id=target_guardian,
-                system_instruction=system_instruction,
-                token=expected,
-                aegis_url=aegis_url,
-                context_id=context_id,
-                skip_grounding=skip_grounding,
-            )
-            _raw_reply = _result.get("text", "") if isinstance(_result, dict) else str(_result)
-            # 🖼️ A2UI 카드 블록(imperial-media/youtube/ask 등)은 디스코드/텔레그램이
-            # 렌더링 못 하므로, 블록 안의 URL만 추출해 평문으로 강등(디스코드 자동 임베드).
-            reply = _sanitize_a2ui_for_relay(_raw_reply)
-            if not reply:
-                reply = _raw_reply
-            user_label = f"{user_name}"
-            if username:
-                user_label += f" (@{username})"
-            if user_id:
-                user_label += f" [{user_id}]"
-            reg_tag = f"✅{role}" if is_registered else "❌미가입"
-            logger.info(f"[📱 {source.upper()}] [{user_label}] ({reg_tag}): {message}")
-            logger.info(f"[📱 {source.upper()}] [ShadowBrain persona={target_guardian}]: {reply}")
-            return jsonify({'reply': reply, 'target_guardian': target_guardian})
-        except Exception as e:
-            logger.error(f"[Telegram Relay Chat] Error: {e}")
-            return jsonify({'error': str(e)}), 500
-
-    # --- Guardian Startup Config API ---
-    @app.route('/api/config/startup', methods=['GET', 'POST', 'OPTIONS'])
-    @app.route('/api/shadow/startup', methods=['GET', 'POST', 'OPTIONS'])
-    def handle_startup_config():
-        """Handles Imperial Guardian Startup configuration (Unified)."""
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-            
-        config_path = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_STARTUP_CONFIG.json")
-        
-        # [Imperial Standard] Full Guardian Template for UI (13 Guardians)
-        DEFAULT_STARTUP = {
-            "core": {"ether": True, "drako": True},
-            "media": {"orpheus": True, "wan2gp": True},
-            "interface": {"heimdall": True, "ether_portal": True},
-            "guardians": {
-                "drako": True,
-                "bahamut": True,
-                "iris": True,
-                "orpheus": True,
-                "wan2gp": True,
-                "heimdall": True,
-                "tiamat": False,
-                "hydra": False,
-                "aizen": False,
-                "hugin": False,
-                "hermes": False,
-                "bastion": True,
-                "atlas": True,
-                "shadow_brain": True,
-                "shadow_rust_brain": True,
-                "pandora": True
-            }
-        }
-        
-        try:
-            if request.method == 'GET':
-                if not os.path.exists(config_path):
-                    return jsonify(DEFAULT_STARTUP)
-                
-                try:
-                    with open(config_path, 'r', encoding='utf-8') as f:
-                        config = json.load(f)
-                    
-                    # Ensure 'guardians' exists for UI stability
-                    if "guardians" not in config:
-                        config["guardians"] = DEFAULT_STARTUP["guardians"]
-                    else:
-                        # [Self-healing] Auto-merge missing guardians from standard template
-                        for k, v in DEFAULT_STARTUP["guardians"].items():
-                            if k not in config["guardians"]:
-                                config["guardians"][k] = v
-                    return jsonify(config)
-                except:
-                    return jsonify(DEFAULT_STARTUP)
-                    
-            elif request.method == 'POST':
-                data = request.json
-                if not data:
-                    return jsonify({"status": "ERROR", "message": "No config data provided"}), 400
-                
-                # Load existing to merge/validate if needed, or total override
-                # Selective merge to protect core structure if partial data sent
-                current = DEFAULT_STARTUP.copy()
-                if os.path.exists(config_path):
-                    try:
-                        with open(config_path, 'r', encoding='utf-8') as f:
-                            current = json.load(f)
-                    except: pass
-                
-                # Merge logic
-                for key in data:
-                    if key in current and isinstance(data[key], dict) and isinstance(current[key], dict):
-                        current[key].update(data[key])
-                    else:
-                        current[key] = data[key]
-                
-                # [Imperial Standard] Ensure atomic write and UTF-8 encoding
-                os.makedirs(os.path.dirname(config_path), exist_ok=True)
-                with open(config_path, 'w', encoding='utf-8') as f:
-                    json.dump(current, f, ensure_ascii=False, indent=2)
-                
-                print(f"[Imperial Config] Startup configuration unified & updated via API.")
-                return jsonify({"status": "SUCCESS", "message": "기동 설정이 갱신되었습니다.", "config": current})
-                
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-
-
-    # --- Imperial Knowledge Endpoints ---
-    @app.route('/api/knowledge/imperial_wisdom', methods=['GET'])
-    @app.route('/api/knowledge/imperial_wisdom.md', methods=['GET'])
-    def api_imperial_wisdom():
-        try:
-            # Log visitor info for debugging help
-            ua = request.headers.get('User-Agent', 'Unknown')
-            ip = request.remote_addr
-            print(f"[Imperial Knowledge] Access attempt - Path: {request.path}, IP: {ip}, UA: {ua}")
-            
-            wisdom_path = os.path.join(project_root, "imperial_wisdom.md")
-            if os.path.exists(wisdom_path):
-                with open(wisdom_path, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                return Response(
-                    content, 
-                    mimetype='text/markdown', 
-                    headers={
-                        'Access-Control-Allow-Origin': '*',
-                        'Access-Control-Allow-Methods': 'GET, OPTIONS',
-                        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-                        'Cache-Control': 'no-cache, no-store, must-revalidate',
-                        'Pragma': 'no-cache',
-                        'Expires': '0'
-                    }
-                )
-            return jsonify({"error": "File not found"}), 404
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/knowledge/mission_control', methods=['GET'])
-    @app.route('/api/knowledge/mission_control.md', methods=['GET'])
-    def api_mission_control():
-        try:
-            ua = request.headers.get('User-Agent', 'Unknown')
-            ip = request.remote_addr
-            print(f"[Imperial Knowledge] Access attempt - Path: {request.path}, IP: {ip}, UA: {ua}")
-            
-            mission_path = os.path.join(project_root, "mission_control.md")
-            if os.path.exists(mission_path):
-                with open(mission_path, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                return Response(
-                    content, 
-                    mimetype='text/markdown', 
-                    headers={
-                        'Access-Control-Allow-Origin': '*',
-                        'Access-Control-Allow-Methods': 'GET, OPTIONS',
-                        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-                        'Cache-Control': 'no-cache, no-store, must-revalidate',
-                        'Pragma': 'no-cache',
-                        'Expires': '0'
-                    }
-                )
-            return jsonify({"error": "File not found"}), 404
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/system/rclone-setup', methods=['POST'])
-    def api_system_rclone_setup():
-        """Triggers the Rclone Google Drive setup script."""
-        try:
-            # Trigger the setup script in the background to avoid blocking the API
-            script_path = os.path.join(project_root, "shadow_brain_core", "rclone_setup.py")
-            if not os.path.exists(script_path):
-                return jsonify({"status": "ERROR", "message": f"Setup script not found: {script_path}"}), 404
-            
-            # Start the setup script - note: this script is interactive, 
-            # so the user will need to interact with the backend console.
-            subprocess.Popen([sys.executable, script_path], creationflags=subprocess.CREATE_NEW_CONSOLE)
-            return jsonify({"status": "SUCCESS", "message": "Rclone setup started in new console."})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    # --- Sovereign Autonomy & Sandbox Endpoints ---
-    @app.route('/api/sovereign/task/start', methods=['POST'])
-    def api_sovereign_task_start():
-        """Starts a new autonomous iterative task."""
-        data = request.json
-        goal = data.get("goal")
-        if not goal:
-            return jsonify({"error": "Goal is required"}), 400
-        
-        context = data.get("context")
-        use_sandbox = data.get("use_sandbox", True)
-        
-        auth_token = request.headers.get("X-Imperial-Token") or request.headers.get("Authorization", "").replace("Bearer ", "")
-        task_id = task_manager.start_task(goal, context=context, use_sandbox=use_sandbox, auth_token=auth_token)
-        return jsonify({"task_id": task_id, "status": "started"})
-
-    @app.route('/api/sovereign/task/status/<task_id>', methods=['GET'])
-    def api_sovereign_task_status(task_id):
-        """Returns the status and logs of an active sovereign task."""
-        status = task_manager.get_task_status(task_id)
-        if not status:
-            return jsonify({"error": "Task not found"}), 404
-        return jsonify(status)
-
-    @app.route('/api/sovereign/sandbox/cleanup', methods=['POST'])
-    def api_sovereign_sandbox_cleanup():
-        """Cleans up a specific sandbox session."""
-        task_id = request.json.get("task_id")
-        if not task_id:
-            return jsonify({"error": "Task ID is required"}), 400
-        success = phantom_sandbox.sandbox_manager.cleanup(task_id)
-        return jsonify({"success": success})
-
-    @app.route('/api/sovereign/browser/execute', methods=['POST'])
-    def api_sovereign_browser_execute():
-        """
-        Executes a high-level browser mission autonomously.
-        Required: {"goal": "Mission description"}
-        Optional: {"headless": true/false}
-        """
-        data = request.json
-        goal = data.get("goal")
-        if not goal:
-            return jsonify({"error": "Goal is required"}), 400
-        
-        headless = data.get("headless", True)
-        
-        # Initialize Agent
-        agent = SovereignMissionAgent()
-        
-        # Execute (Runs in blocking mode for now, but could be threaded)
-        # For simplicity and 'Accuracy' (user's request), we run and report.
-        try:
-            result = agent.execute_mission(goal, headless=headless)
-            return jsonify(result)
-        except Exception as e:
-            return jsonify({"status": "error", "error": str(e)}), 500
-
-    # --- Phase 32: Imperial Data Isolation (JarvisRun Folder) ---
-
-
-    # --- Phase 32: Imperial Data Isolation (JarvisRun Folder) ---
-
-    jarvis_run_dir = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun")
-
-    os.makedirs(jarvis_run_dir, exist_ok=True)
-
-
-
-    # --- Phase 69: Persistence of Proactive Settings ---
-    # Moved to blueprints/report_routes.py
-
-    def migrate_legacy_data():
-
-        """Migrates files from shared_workspace root to JarvisRun subdirectory."""
-
-        root_dir = os.path.join(project_root, "docker_data", "shared_workspace")
-
-        legacy_files = [
-
-            "JARVIS_SIGNAL.json", "JARVIS_TODO.json", "JARVIS_TODO_ARCHIVE.json",
-
-            "JARVIS_TERMINAL.log", "JARVIS_CHAT_HISTORY.json", "JARVIS_SHADOW_SETTINGS.json",
-
-            "JARVIS_VOICE_SIGNAL.json", "JARVIS_AUTOTEST.json", "SHADOW_BRAIN_MODELS.json",
-
-            "REDTEAM_TARGETS.json", "REDTEAM_TACTICAL_REPORT.json", "SOUL_LINK_LOG.json",
-
-            "JARVISRUN_STATUS.json"
-
-        ]
-
-        import shutil
-
-        for f in legacy_files:
-
-            old_path = os.path.join(root_dir, f)
-
-            if os.path.exists(old_path):
-
-                new_path = os.path.join(jarvis_run_dir, f)
-
-                if not os.path.exists(new_path):
-
-                    try:
-
-                        shutil.move(old_path, new_path)
-
-                        print(f"[Imperial Migration] {f} -> JarvisRun/")
-
-                    except Exception as e:
-
-                        print(f"[Migration Error] {f}: {e}")
-
-                else:
-
-                    try:
-
-                        os.remove(old_path) # Data already exists in new area
-
-                    except: pass
-
-        
-
-        # Also migrate PNG evidence files
-
-        for f in os.listdir(root_dir):
-
-            if f.endswith(".png") and os.path.isfile(os.path.join(root_dir, f)):
-
-                try:
-
-                    shutil.move(os.path.join(root_dir, f), os.path.join(jarvis_run_dir, f))
-
-                except: pass
-
-
-
-    migrate_legacy_data()
-
-
-
-    # --- Phase 33: Version Sync from VERSION file to JARVISRUN_STATUS.json ---
-
-    def sync_version_to_status():
-        """Reads the root VERSION file and updates JARVISRUN_STATUS.json with the canonical version."""
-        version_file = os.path.join(project_root, "VERSION")
-        status_file = os.path.join(jarvis_run_dir, "JARVISRUN_STATUS.json")
-        try:
-            with open(version_file, 'r', encoding='utf-8-sig') as f:
-                version_str = f.read().strip()
-        except OSError as e:
-            print(f"[Imperial Version Sync] Warning: Could not read VERSION file ({version_file}): {e}")
-            return
-        if not os.path.exists(status_file):
-            print(f"[Imperial Version Sync] Warning: Status file not found ({status_file}), skipping version sync.")
-            return
-        try:
-            with open(status_file, 'r', encoding='utf-8') as f:
-                status_data = json.load(f)
-            status_data['version'] = version_str
-            with open(status_file, 'w', encoding='utf-8') as f:
-                json.dump(status_data, f, ensure_ascii=False, indent=2)
-            print(f"[Imperial Version Sync] JARVISRUN_STATUS.json version updated to: {version_str}")
-        except (OSError, json.JSONDecodeError) as e:
-            print(f"[Imperial Version Sync] Warning: Could not update status file ({status_file}): {e}")
-
-    sync_version_to_status()
-
-
-
-    # --- Phase 40: Deployment State Tracking ---
-
-    deployment_status = {}
-
-    secrets_sync_status = {"status": "IDLE", "step": "N/A"}
-
-
-
-    @app.route('/api/deploy/status', methods=['GET'])
-
-    def get_deploy_status():
-
-        """Returns the current deployment status of all projects."""
-
-        return jsonify(deployment_status)
-
-
-
-    # === Firebase Build Quota Tracker ===
-
-    QUOTA_FILE = os.path.join(project_root, "docker_data", "shared_workspace", "firebase_build_quota.json")
-
-    FIREBASE_FREE_BUILDS = 30  # ~120min / ~4min per build
-
-
-
-    def _load_quota():
-
-        """Load or reset monthly build quota."""
-
-        import json
-
-        from datetime import datetime
-
-        current_month = datetime.now().strftime('%Y-%m')
-
-        try:
-
-            with open(QUOTA_FILE, 'r', encoding='utf-8') as f:
-
-                data = json.load(f)
-
-            if data.get('month') != current_month:
-
-                data = {'month': current_month, 'count': 0, 'manual_count': 0, 'limit': FIREBASE_FREE_BUILDS}
-
-                _save_quota(data)
-
-            if 'manual_count' not in data:
-
-                data['manual_count'] = 0
-
-                _save_quota(data)
-
-            return data
-
-        except (FileNotFoundError, json.JSONDecodeError):
-
-            data = {'month': current_month, 'count': 0, 'manual_count': 0, 'limit': FIREBASE_FREE_BUILDS}
-
-            _save_quota(data)
-
-            return data
-
-
-
-    def _save_quota(data):
-
-        import json
-
-        os.makedirs(os.path.dirname(QUOTA_FILE), exist_ok=True)
-
-        with open(QUOTA_FILE, 'w', encoding='utf-8') as f:
-
-            json.dump(data, f, ensure_ascii=False, indent=2)
-
-
-
-    def _increment_quota():
-
-        data = _load_quota()
-
-        data['count'] = data.get('count', 0) + 1
-
-        _save_quota(data)
-
-        return data
-
-
-
-    @app.route('/api/deploy/quota', methods=['GET'])
-
-    def get_deploy_quota():
-
-        """Returns Firebase build quota usage for current month."""
-
-        data = _load_quota()
-
-        remaining = max(0, data['limit'] - data['count'])
-
-        percent = round((data['count'] / data['limit']) * 100) if data['limit'] > 0 else 0
-
-        level = 'safe' if percent < 70 else ('warning' if percent < 90 else 'danger')
-
-        
-
-        # Storage usage estimate removed in favor of direct GCP Console monitoring
-        storage_used = 0.0
-        storage_limit = 5.0 # Firebase Spark Plan limit
-        storage_percent = 0
-        storage_level = 'safe'
-
-        
-
-        return jsonify({
-
-            'month': data['month'],
-
-            'used': data['count'],
-
-            'limit': data['limit'],
-
-            'remaining': remaining,
-
-            'percent': percent,
-
-            'level': level,
-
-            'storage': {
-
-                'used': storage_used,
-
-                'limit': storage_limit,
-
-                'percent': storage_percent,
-
-                'level': storage_level,
-
-                'manual_count': data['manual_count']
-
-            }
-
-        })
-
-
-
-    @app.route('/api/deploy/storage/purge', methods=['POST'])
-
-    def purge_deploy_storage():
-
-        """Resets the manual deployment counter after user cleans up Firebase Console."""
-
-        data = _load_quota()
-
-        data['manual_count'] = 0
-
-        _save_quota(data)
-
-        return jsonify({"status": "SUCCESS", "message": "Manual deployment counter reset. Imperial Sanctuary purified."})
-
-
-
-    @app.route('/api/deploy/quota/sync', methods=['POST'])
-
-    def sync_deploy_quota():
-
-        """Manually override the current month's build quota."""
-
-        req = request.json
-
-        if 'used' not in req:
-
-            return jsonify({"status": "ERROR", "message": "Missing 'used' parameter"}), 400
-
-            
-
-        data = _load_quota()
-
-        data['count'] = int(req['used'])
-
-        _save_quota(data)
-
-        return jsonify({"status": "SUCCESS", "message": f"Quota synced to {data['count']}"})
-
-
-
-    @app.route('/api/secrets/sync/status', methods=['GET'])
-
-    def get_secrets_sync_status():
-
-        return jsonify(secrets_sync_status)
-
-
-
-    @app.route('/api/deploy/db/status', methods=['GET'])
-    def get_db_schema_status():
-        """Returns the current Prisma migration status for the project."""
-        project = request.args.get("project", "ether_bahamut")
-        if project != "ether_bahamut":
-            return jsonify({"status": "UNSUPPORTED", "message": "이 프로젝트는 키 감시를 지원하지 않습니다."})
-
-        def check_db():
-            try:
-                # 1. Get DB URL from Bitwarden
-                bw_session = os.environ.get("BW_SESSION")
-                if not bw_session:
-                    return {"status": "LOCKED", "message": "Bitwarden Vault가 잠겨 있습니다."}
-
-                # Get the preview URL for status checks
-                cmd_get_secret = 'powershell -Command "bw get password \'Imperial: PREVIEW_DATABASE_URL\' --raw"'
-                res_secret = subprocess.run(cmd_get_secret, shell=True, capture_output=True, text=True, encoding='utf-8')
-                db_url = res_secret.stdout.strip().replace('"', '').replace("'", "")
-                
-                if not db_url or "Auto-migrated" in db_url:
-                    return {"status": "ERROR", "message": "DB URL을 찾을 수 없습니다."}
-
-                # 2. Run prisma migrate status
-                target_dir = os.path.join(project_root, "ether-bahamut")
-                env_copy = os.environ.copy()
-                env_copy["DATABASE_URL"] = db_url
-                
-                # Check for prisma existence
-                cmd_status = "npx.cmd prisma migrate status"
-                res_status = subprocess.run(cmd_status, shell=True, cwd=target_dir, env=env_copy, capture_output=True, text=True, encoding='utf-8')
-                
-                output = res_status.stdout + res_status.stderr
-                if "Database schema is up to date" in output:
-                    return {"status": "SYNCED", "message": "최신 상태 (동기화됨)"}
-                elif "migrations are not yet applied" in output:
-                    # Count pending migrations if possible
-                    return {"status": "PENDING", "message": "⚠️ 마이그레이션 필요"}
-                elif "error" in output.lower():
-                    return {"status": "ERROR", "message": "DB 연결 오류"}
-                else:
-                    return {"status": "UNKNOWN", "message": "상태 확인 불가"}
-                    
-            except Exception as e:
-                return {"status": "ERROR", "message": f"시스템 오류: {str(e)}"}
-
-        result = check_db()
-        return jsonify(result)
-
-
-
-    # [🔱 Imperial] Deployment logic has been migrated to blueprints/deployment_routes.py\n    @app.route('/redteam')
-
-    def redteam_console():
-
-        """Serves the Red Team tactical audit interface."""
-
-        return render_template('redteam.html')
-
-
-
-    # [🔱 Imperial] Red Team audit logic has been migrated to blueprints/audit_routes.py
-    def serve_guardian_assets(guardian_id, filename):
-        """Serves assets from specific guardian workspaces (Soul Bridge)."""
-        from flask import send_from_directory
-        workspace_map = {
-            "hugin": os.path.join(project_root, "scripts", "hugin"),
-            "shadowbrain": os.path.join(os.path.dirname(project_root), "docker_data", "shared_workspace", "JarvisRun"),
-            "jarvis": os.path.join(os.path.dirname(project_root), "docker_data", "shared_workspace", "JarvisRun"),
-            "aris": os.path.join(project_root, "docker_data", "shared_workspace", "Aris")
-        }
-        base_path = workspace_map.get(guardian_id.lower())
-        
-        if not base_path:
-            base_path = os.path.join(project_root, "docker_data", "shared_workspace", guardian_id.capitalize())
-            
-        if os.path.exists(base_path):
-            return send_from_directory(base_path, filename)
-        return jsonify({"error": "Workspace not found"}), 404
-
-    def _is_flutter_debug_server_running(port=38790):
-        """flutter run --debug 서버(38790)가 기동 중인지 빠르게 체크합니다."""
-        import socket as _socket
-        s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
-        s.settimeout(0.1)
-        try:
-            s.connect(('127.0.0.1', port))
-            s.close()
-            return True
-        except Exception:
-            return False
-
-    @app.route('/')
-
-    def index():
-
-        # flutter run --debug 서버(38790)가 살아 있으면 그쪽으로 리다이렉트 (최신 코드)
-        # 🔱 RunJarvis_Web.bat 개발 중일 때 18700과 38790이 자동 연동됨
-        from flask import redirect as _redirect
-        if _is_flutter_debug_server_running(38790):
-            return _redirect('http://localhost:38790/', code=302)
-
-        # Serve the main index.html (Heimdall or Legacy)
-
-        target = 'index.html' if os.path.exists(os.path.join(app.static_folder, 'index.html')) else 'dashboard.html'
-
-        from flask import make_response, send_from_directory
-
-        return send_from_directory(app.static_folder, target)
-
-
-
-    @app.route('/api/status')
-
-    def status():
-
-        status_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVISRUN_STATUS.json")
-
-        try:
-
-            if os.path.exists(status_file):
-
-                with open(status_file, 'r', encoding='utf-8') as f:
-
-                    data = json.load(f)
-
-                
-
-                # --- Phase: Eternal Watch Status ---
-
-                data['external_health'] = data.get('external_services', {})
-
-                
-
-                # --- Phase 5: Guardian Location Display ---
-
-                if cluster:
-
-                    try:
-
-                        data['allocations'] = cluster.get_config().get('allocations', {})
-
-                    except Exception:
-
-                        data['allocations'] = {}
-
-
-
-                # Staleness check: if heartbeat is older than 45 seconds,
-
-                # the engine is stopped/restarting - treat all guardians as offline
-
-                ts = data.get('timestamp', 0)
-
-                age = time.time() - ts
-
-                if age > 45:
-
-                    stale_guardians = {k: False for k in data.get('guardians', {})}
-
-                    data['guardians'] = stale_guardians
-
-                    data['stale'] = True
-
-                    data['stale_age'] = int(age)
-                    
-                # [🔱] Guardian Ports Mapping for UI (Fallback for Shadow Brain)
-                # Map standard keys to ports
-                port_map = {
-                    "drako": "5432", "orpheus": "18800", "wan2gp": "8003",
-                    "heimdall": "18701", "aizen": "18789", "hugin": "18792", 
-                    "hermes": "18790", "shadow_brain": "18700", "shadow_rust_brain": "18710", 
-                    "hydra": "8002", "tiamat": "8080", "atlas": "18799", 
-                    "bastion": "18702", "gemini_voice": "18721", "pandora": "8001", 
-                    "bahamut": "3002", "ether": "3002", "iris": "4000", "ether_portal": "4000"
-                }
-                
-                # Create guardian_ports mapping matching the exact keys found in data['guardians']
-                # or based on known labels if the keys are complex labels
-                guardian_ports = {}
-                guardians = data.get('guardians', {})
-                for k in guardians.keys():
-                    port = ""
-                    k_lower = k.lower()
-                    for std_k, p in port_map.items():
-                        if std_k in k_lower:
-                            port = p
-                            break
-                    guardian_ports[k] = port
-                
-                data['guardian_ports'] = guardian_ports
-
-                return jsonify(data)
-
-        except Exception as e:
-
-            return jsonify({"error": str(e)}), 500
-
-        return jsonify({"status": "OFFLINE"})
-
-
-
-    @app.route('/api/status/sync', methods=['GET', 'POST'])
-
-    def handle_sync_status():
-
-        global is_syncing
-
-        from flask import request
-
-        if request.method == 'POST':
-
-            data = request.json
-
-            is_syncing = data.get("is_syncing", False)
-
-            print(f"[.env Migration] Syncing state set to: {is_syncing}")
-
-            return jsonify({"status": "SUCCESS", "is_syncing": is_syncing})
-
-        else:
-
-            return jsonify({"is_syncing": is_syncing})
-
-
-
-    @app.route('/api/config')
-
-    def get_config():
-
-        version_file = os.path.join(project_root, "VERSION")
-        try:
-            with open(version_file, 'r', encoding='utf-8-sig') as f:
-                version_str = f.read().strip()
-        except Exception:
-            version_str = "UNKNOWN"
-
-        return jsonify({
-
-            "version": version_str,
-
-            "dev_mode": "ACTIVE",
-
-            "neural_link_stability": "99.9%",
-
-            "last_sync": os.path.getmtime(__file__)
-
-        })
-
-
-    @app.route('/api/shadow/ask/answer', methods=['POST', 'OPTIONS'])
-    def shadow_ask_answer():
-        """🙋 [Ask User] 헤임달 선택지 버튼 탭 수신 — 대기 중인 추론 루프를 깨운다."""
-        if request.method == 'OPTIONS':
-            return '', 204
-        try:
-            data = request.json or {}
-            ask_id = str(data.get('ask_id') or '').strip()
-            # 🚫 취소 신호 (수호자 전환/창 닫기 등) — 대기 루프가 즉시 깨어나 보수적으로 마무리
-            answer = "__CANCELLED__" if data.get('cancel') else str(data.get('answer') or '').strip()
-            if not ask_id or not answer:
-                return jsonify({"status": "ERROR", "message": "ask_id와 answer는 필수입니다."}), 400
-            from brain.core import submit_ask_answer
-            if submit_ask_answer(ask_id, answer):
-                return jsonify({"status": "SUCCESS", "ask_id": ask_id})
-            # 만료/취소된 질문 — 헤임달은 이 응답을 받으면 일반 채팅 메시지로 폴백 전송
-            return jsonify({"status": "EXPIRED", "message": "해당 질문은 이미 만료되었거나 취소되었습니다."}), 410
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/shadow/ask/begin', methods=['POST', 'OPTIONS'])
-    def shadow_ask_begin():
-        """🙋 [Ask Bridge] 외부 에이전트(헤르메스 MCP 등)가 선택지 질문을 등록한다."""
-        if request.method == 'OPTIONS':
-            return '', 204
-        try:
-            data = request.json or {}
-            if not str(data.get('question', '')).strip() or not data.get('options'):
-                return jsonify({"status": "ERROR", "message": "question과 options는 필수입니다."}), 400
-            from brain.core import begin_ask
-            return jsonify({"status": "SUCCESS", "ask": begin_ask(data)})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/shadow/ask/wait', methods=['POST', 'OPTIONS'])
-    def shadow_ask_wait():
-        """🙋 [Ask Bridge] 답변까지 블로킹 대기(long-poll). ANSWERED/CANCELLED/TIMEOUT 반환."""
-        if request.method == 'OPTIONS':
-            return '', 204
-        try:
-            data = request.json or {}
-            ask_id = str(data.get('ask_id') or '').strip()
-            if not ask_id:
-                return jsonify({"status": "ERROR", "message": "ask_id는 필수입니다."}), 400
-            timeout = max(5, min(int(data.get('timeout_seconds', 120) or 120), 600))
-            from brain.core import wait_ask
-            answer = wait_ask(ask_id, timeout)
-            if answer is None:
-                return jsonify({"status": "TIMEOUT"})
-            if answer == "__CANCELLED__":
-                return jsonify({"status": "CANCELLED"})
-            return jsonify({"status": "ANSWERED", "answer": answer})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/shadow/ask/pending', methods=['GET', 'OPTIONS'])
-    def shadow_ask_pending():
-        """🙋 [Ask Bridge] 대기 중 질문 목록 — 헤임달이 폴링하여 카드를 out-of-band 표시."""
-        if request.method == 'OPTIONS':
-            return '', 204
-        try:
-            from brain.core import list_pending_asks
-            return jsonify({"status": "SUCCESS", "asks": list_pending_asks()})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e), "asks": []}), 200
-
-    @app.route('/api/shadow/web_search', methods=['POST', 'OPTIONS'])
-    def shadow_web_search():
-        """🌐 [Web Search] 실시간 웹 검색 — 내부 google-surf MCP를 호출해 결과 텍스트를 반환.
-
-        imperial MCP의 web 번들(search_web)이 이 엔드포인트를 호출한다. 덕분에 외부
-        수호자(헤르메스 등)는 google-surf npm 서버를 따로 안 깔고 우리 MCP만으로 검색하며,
-        실제 검색(브라우저)은 쉐도우 브레인에서 중앙 실행된다.
-        """
-        if request.method == 'OPTIONS':
-            return '', 204
-        data = request.get_json(silent=True) or {}
-        query = (data.get('query') or data.get('q') or '').strip()
-        if not query:
-            return jsonify({"status": "ERROR", "message": "query가 필요합니다."}), 400
-        try:
-            limit = max(1, min(10, int(data.get('limit', 5))))
-        except (TypeError, ValueError):
-            limit = 5
-        try:
-            # 환경 무관 동작: google-surf(브라우저 MCP)가 연결돼 있으면 사용(로컬/주거용 IP에 적합),
-            # 미연결이면(클라우드 등) 네이버 headless Playwright(local_playwright_search)로 폴백한다.
-            # → 구글은 데이터센터 IP에서 캡차로 막히므로 클라우드에선 네이버 경로가 자동 사용됨.
-            from mcp_client import get_mcp_client
-            _mc = get_mcp_client() if get_mcp_client else None
-            _has_surf = bool(_mc and 'google-surf' in getattr(_mc, '_active_servers', []))
-            if _has_surf:
-                result = _mc.call_tool_sync('google-surf', 'search',
-                                            {"query": query[:400], "limit": limit}, timeout=150)
-            elif jarvis_brain is not None and getattr(jarvis_brain, 'browser', None) is not None:
-                # 네이버→다음→구글 headless 검색 (구글 캡차/디스플레이 무관, API 키 불필요)
-                result = jarvis_brain.browser.local_playwright_search(query[:400])
-            else:
-                return jsonify({"status": "ERROR",
-                                "message": "검색 엔진 미가용 (google-surf/Playwright 모두 불가)"}), 503
-            return jsonify({"status": "SUCCESS", "query": query, "result": result})
-        except Exception as e:
-            logger.error(f"[Web Search] 실패: {e}")
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/mcp/directories', methods=['GET', 'POST', 'OPTIONS'])
-    def manage_mcp_directories():
-        if request.method == 'OPTIONS':
-            return '', 204
-
-        # [🔱 Writable MCP Config] 쓰기 가능한 사용자 폴더(LOCALAPPDATA) 사본을 읽고 쓴다.
-        # (Program Files 사본은 권한 때문에 저장 불가)
-        try:
-            from mcp_client import resolve_mcp_config_path
-            mcp_config_path = resolve_mcp_config_path()
-        except Exception:
-            mcp_config_path = os.path.join(core_root, 'mcp_servers.json')
-
-        if request.method == 'GET':
-            try:
-                if not os.path.exists(mcp_config_path):
-                    return jsonify({"status": "SUCCESS", "directories": []})
-                with open(mcp_config_path, 'r', encoding='utf-8') as f:
-                    config = json.load(f)
-                
-                directories = []
-                for server in config.get('servers', []):
-                    if server.get('name') == 'filesystem':
-                        args = server.get('args', [])
-                        try:
-                            idx = args.index("@modelcontextprotocol/server-filesystem")
-                            directories = args[idx+1:]
-                        except ValueError:
-                            pass
-                return jsonify({"status": "SUCCESS", "directories": directories})
-            except Exception as e:
-                logger.error(f"[MCP API] Failed to read directories: {e}")
-                return jsonify({"status": "ERROR", "message": str(e)}), 500
-                
-        elif request.method == 'POST':
-            try:
-                data = request.json or {}
-                new_dirs = data.get('directories', [])
-                if not isinstance(new_dirs, list):
-                    return jsonify({"status": "ERROR", "message": "directories must be a list"}), 400
-                
-                # [🔱 Imperial Fix] mcp_servers.json 없으면 기본 구조로 자동 생성
-                if not os.path.exists(mcp_config_path):
-                    logger.info("[MCP API] mcp_servers.json not found. Creating default config...")
-                    default_config = {
-                        "servers": [
-                            {
-                                "name": "filesystem",
-                                "command": "npx",
-                                "args": ["-y", "@modelcontextprotocol/server-filesystem"]
-                            }
-                        ]
-                    }
-                    with open(mcp_config_path, 'w', encoding='utf-8') as f:
-                        json.dump(default_config, f, indent=2, ensure_ascii=False)
-                
-                with open(mcp_config_path, 'r', encoding='utf-8') as f:
-                    config = json.load(f)
-                
-                # filesystem 서버 탐색 및 업데이트
-                updated = False
-                for server in config.get('servers', []):
-                    if server.get('name') == 'filesystem':
-                        base_args = ["-y", "@modelcontextprotocol/server-filesystem"]
-                        server['args'] = base_args + new_dirs
-                        updated = True
-                        break
-                
-                # filesystem 서버가 없으면 새로 추가
-                if not updated:
-                    if 'servers' not in config:
-                        config['servers'] = []
-                    config['servers'].append({
-                        "name": "filesystem",
-                        "command": "npx",
-                        "args": ["-y", "@modelcontextprotocol/server-filesystem"] + new_dirs
-                    })
-                    updated = True
-                        
-                with open(mcp_config_path, 'w', encoding='utf-8') as f:
-                    json.dump(config, f, indent=2, ensure_ascii=False)
-                return jsonify({"status": "SUCCESS", "message": "MCP directories updated. Restart required."})
-            except Exception as e:
-                logger.error(f"[MCP API] Failed to update directories: {e}")
-                return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-
-    @app.route('/api/logs')
-
-    def get_logs():
-
-        log_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_TERMINAL.log")
-
-        try:
-
-            if os.path.exists(log_file):
-                with open(log_file, 'r', encoding='utf-8', errors='replace') as f:
-                    lines = f.readlines()
-                    return jsonify({"logs": lines[-500:]}) # Standard Imperial Buffer Size
-
-        except Exception as e:
-
-            return jsonify({"error": str(e)}), 500
-
-        return jsonify({"logs": ["Initializing tactical link..."]})
-
-
-
-    @app.route('/api/imperial/health')
-
-    def imperial_health():
-
-        """Returns the health status of external cloud services (Eternal Watch)."""
-
-        status_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVISRUN_STATUS.json")
-
-        try:
-
-            if os.path.exists(status_file):
-
-                with open(status_file, 'r', encoding='utf-8') as f:
-
-                    data = json.load(f)
-
-                
-
-                # Extract external services info
-
-                external_services = data.get('external_services', {
-
-                    "n8n": {"status": "UNKNOWN", "last_check": 0},
-
-                    "supabase_prod": {"status": "UNKNOWN", "last_check": 0},
-
-                    "supabase_dev": {"status": "UNKNOWN", "last_check": 0},
-
-                    "nhost": {"status": "UNKNOWN", "last_check": 0}
-
-                })
-
-                
-
-                return jsonify({
-
-                    "status": "ONLINE",
-
-                    "services": external_services,
-
-                    "timestamp": time.time()
-
-                })
-
-        except Exception as e:
-
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-        return jsonify({"status": "OFFLINE", "services": {}})
-
-
-
-    def archive_old_missions(todos, archive_limit=15):
-        """Legacy stub."""
-        return todos
-
-        completed = [t for t in todos if t.get('status') == 'COMPLETED']
-
-        if len(completed) <= archive_limit:
-
-            return todos
-
-        
-
-        # Sort by timestamp to find oldest
-
-        completed.sort(key=lambda x: x.get('timestamp', 0))
-
-        
-
-        to_archive = completed[:len(completed) - archive_limit]
-
-        archive_ids = {t['id'] for t in to_archive}
-
-        
-
-        remaining_todos = [t for t in todos if t['id'] not in archive_ids]
-
-        
-
-        archive_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_TODO_ARCHIVE.json")
-
-        archived_data = []
-
-        if os.path.exists(archive_file):
-
-            try:
-
-                with open(archive_file, 'r', encoding='utf-8') as f:
-
-                    archived_data = json.load(f)
-
-            except Exception: pass
-
-            
-
-        archived_data.extend(to_archive)
-
-        
-
-        try:
-
-            with open(archive_file, 'w', encoding='utf-8') as f:
-
-                json.dump(archived_data, f, ensure_ascii=False, indent=2)
-
-            print(f"[Imperial Archive] Moved {len(to_archive)} missions to archive.")
-
-        except Exception as e:
-
-            print(f"[ERROR] Archiving failed: {e}")
-
-            
-
-        return remaining_todos
-
-
-
-    def sync_missions_to_markdown(todos):
-        """Legacy stub."""
-        return
-
-        try:
-
-            mc_path = os.path.join(project_root, "mission_control.md")
-
-            content = "# Imperial Task Control (황실 작전 제어실)\n\n"
-
-            content += "> [!IMPORTANT]\n"
-
-            content += f"> 이 문서는 자비스(Antigravity)가 현재 상태를 시간순으로 기록하는 **제국 공식 관제 센터**입니다. (Last Updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')})\n\n"
-
-            
-
-            content += "## ⚡ 현재 진행 중인 테스크 (Active Tasks)\n\n"
-
-            active = [t for t in todos if t.get('status') != 'COMPLETED' and t.get('status') != 'ARCHIVED']
-
-            
-
-            if not active:
-
-                content += "*현재 진행 중인 ���스크가 없습니다. 마왕님의 명령을 대기 중입니다.*\n\n"
-
-            else:
-
-                content += "| ID | 테스크 과업(Task) | 상태 (Status) | 보고 내용 (Report) |\n"
-
-                content += "| :--- | :--- | :--- | :--- |\n"
-
-                for t in active:
-
-                    # Escape pipe characters for markdown table
-
-                    task = str(t.get('task', '')).replace('|', '\\|')
-
-                    status = str(t.get('status', 'PENDING')).replace('|', '\\|')
-
-                    report = str(t.get('report', '')).replace('|', '\\|').replace('\n', '<br>')
-
-                    content += f"| {t.get('id')} | {task} | **{status}** | {report} |\n"
-
-                content += "\n"
-
-
-
-            content += "## 🔱 완수된 제국 공훈 (Completed Missions)\n\n"
-
-            completed = [t for t in todos if t.get('status') == 'COMPLETED']
-
-            if not completed:
-
-                content += "*아직 완수한 테스크가 없습니다.*\n\n"
-
-            else:
-
-                for t in reversed(completed):
-
-                    content += f"### 🔱 {t.get('task')}\n"
-
-                    content += f"- **ID**: {t.get('id')}\n"
-
-                    content += f"- **종료 일시**: {datetime.fromtimestamp(t.get('timestamp', 0)).strftime('%Y-%m-%d %H:%M:%S')}\n"
-
-                    # [🔱 Imperial v2.5.2] Python 3.10 compatibility: extract backslash operation from f-string
-                    report_formatted = str(t.get('report', '')).replace('\n', '\n> ')
-                    content += f"- **최종 보고**:\n> {report_formatted}\n\n"
-
-                    content += "---\n\n"
-
-
-
-            with open(mc_path, 'w', encoding='utf-8') as f:
-                f.write(content)
-            print(f"[Neural Link] mission_control.md synchronized successfully.")
-            
-            # Sync to Google Drive
-            gdrive_sync.sync_to_gdrive("mission_control.md", content)
-
-        except Exception as e:
-
-            print(f"[ERROR] Sync to markdown failed: {e}")
-
-
-
-
-    # [REMOVED] Mission (Todo) management is now exclusively handled by Django 
-    # Fortress (Port 18701) to ensure SSOT and AEGIS protection.
-
-    # [🔱 Imperial Command Router] (Moved to blueprints/system_routes.py)
-
-
-
-
-    def _resolve_guardian_id(gid):
-        """[🔱 Imperial] Resolve UUIDs, Ports, or Full Names to Internal Short IDs"""
-        mapping = {
-            "18800": "orpheus",
-            "orpheus": "orpheus",
-            "오르페우스 (뮤즈의 메아리)": "orpheus",
-            "5d4d6c6f-0767-4af4-bdc4-90eea624c8ca": "orpheus",
-            "aizen": "aizen",
-            "아이젠 (성역의 서고)": "aizen",
-            "542f42a5-7b90-4537-b751-5218e3c09d54": "aizen",
-            "aegis": "aegis",
-            "애기스 (황실 절대 방벽)": "aegis",
-            "88092a79-174b-4899-9ce4-465c52791bed": "aegis",
-            "hermes": "hermes",
-            "헤르메스 (전령의 발걸음)": "hermes",
-            "f4980714-58da-4e4b-aea3-8746bded4c12": "hermes"
-        }
-        # 1. Direct Map
-        res = mapping.get(gid)
-        if res: return res
-        
-        # 2. Database Lookup (Fallback for new guardians)
-        try:
-            conn = get_db_connection()
-            if conn:
-                with conn.cursor() as cur:
-                    cur.execute("SELECT canonical_name, name FROM taemingames.guardian_personas WHERE id::text = %s OR name = %s", (gid, gid))
-                    row = cur.fetchone()
-                    if row:
-                        db_canonical = row[0]
-                        db_name = row[1]
-                        # Map based on known canonicals or keywords
-                        if db_canonical and db_canonical in mapping: return mapping[db_canonical]
-                        if "오르페우스" in (db_name or ""): return "orpheus"
-                        if "아이젠" in (db_name or ""): return "aizen"
-                conn.close()
-        except Exception as db_err:
-            logger.warning(f"⚠️ [Imperial Mapping] DB Lookup failed for {gid}: {db_err}")
-            
-        return gid
-
-    @app.route('/api/guardian/<guardian_id>/<action>', methods=['POST'])
-    def execute_guardian_action(guardian_id, action):
-        """Web interface for single Guardian ON/OFF toggles"""
-        # [🔱 Imperial] Resolve ID first
-        original_id = guardian_id
-        guardian_id = _resolve_guardian_id(guardian_id)
-        
-        paths = {
-            "aizen": {"start": "scripts/aizen/start_aizen.ps1", "stop": "scripts/aizen/stop_aizen.ps1", "title": "Aizen Guardian"},
-            "aris": {"start": "scripts/backend/start-backend.bat", "stop": "scripts/backend/stop-backend.bat", "title": "Aris Guardian"},
-            "gilgamesh": {"start": "scripts/openclaw/openclaw-start-native-pro.bat", "stop": "scripts/openclaw/openclaw-stop-native-pro.bat", "title": "Gilgamesh Guardian"},
-            "app": {"start": "scripts/ether-bahamut/start-ether.bat", "stop": "scripts/ether-bahamut/stop-ether.bat", "title": "Bahamut (Core)"},
-            "bahamut": {"start": "scripts/ether-bahamut/start-ether.bat", "stop": "scripts/ether-bahamut/stop-ether.bat", "title": "Bahamut (Aegis)"},
-            "aegis": {"start": "scripts/security/aegis-guardian.ps1", "stop": "scripts/security/stop-aegis.ps1", "title": "Aegis Guardian"},
-            "qwen": {"start": "scripts/jarvisrun/start_qwen_tts.ps1", "stop": "scripts/jarvisrun/stop_qwen_tts.ps1", "title": "Qwen TTS"},
-            "orpheus": {"start": "scripts/jarvisrun/start_qwen_tts.ps1", "stop": "scripts/jarvisrun/stop_qwen_tts.ps1", "title": "Orpheus (Qwen3-TTS)"},
-            "aris-ui": {"start": "scripts/aris-ui/start_aris_ui.ps1", "stop": "scripts/aris-ui/stop_aris_ui.ps1", "title": "Aris-UI Guardian"},
-            "drako": {"start": "scripts/database/start-drako.bat", "stop": "scripts/database/stop-drako.bat", "title": "Drako Guardian"},
-            "wan2gp": {"start": "scripts/wan2gp/start_wan2gp.ps1", "stop": "scripts/wan2gp/stop_wan2gp.ps1", "title": "Hephaestus (Wan2GP)"},
-            "hephaestus": {"start": "scripts/wan2gp/start_wan2gp.ps1", "stop": "scripts/wan2gp/stop_wan2gp.ps1", "title": "Hephaestus (Wan2GP)"},
-            "ether-portal": {"start": "scripts/ether-portal/start_ether_portal.ps1", "stop": "scripts/ether-portal/stop_ether_portal.ps1", "title": "Tiamat (Portal)"},
-            "tiamat": {"start": "scripts/ether-portal/start_ether_portal.ps1", "stop": "scripts/ether-portal/stop_ether_portal.ps1", "title": "Tiamat (Portal)"},
-            "ether_portal": {"start": "scripts/ether-portal/start_ether_portal.ps1", "stop": "scripts/ether-portal/stop_ether_portal.ps1", "title": "Tiamat (Portal)"},
-            "heimdall": {"start": "RunJarvis_Web.bat", "stop": "scripts/jarvisrun/stop_heimdall.ps1", "title": "Heimdall (Eye)"},
-            "hydra": {"start": "scripts/hydra/start_hydra.ps1", "stop": "scripts/hydra/stop_hydra.ps1", "title": "Hydra (Multi-Agent)"},
-            "hugin": {"start": "scripts/jarvis/start_jarvis_relay.ps1", "stop": "scripts/jarvis/stop_jarvis_relay.ps1", "title": "Hugin (Recon Eye)"},
-            "hermes": {"start": "scripts/security/start_hermes.ps1", "stop": "scripts/security/stop_hermes.ps1", "title": "Hermes (Tunnel)"}
-        }
-
-        if guardian_id not in paths:
-            logger.error(f"🛑 [Imperial Command] Unknown guardian: {guardian_id} (Resolved from: {original_id})")
-            return jsonify({"status": "ERROR", "message": f"Unknown guardian: {guardian_id}"}), 400
-            
-        script_rel = paths[guardian_id].get(action)
-        title = paths[guardian_id]["title"]
-        if not script_rel:
-            return jsonify({"status": "ERROR", "message": f"Unknown action: {action}"}), 400
-
-        full_path = os.path.join(project_root, os.path.normpath(script_rel))
-        
-        try:
-            # [🔱 Imperial Cluster Relay]
-            if cluster:
-                # Use a safe access pattern to avoid AttributeError
-                config = {}
-                try:
-                    config = cluster.get_config()
-                except Exception as cfg_err:
-                    logger.warning(f"⚠️ [Imperial Cluster] Failed to get live config: {cfg_err}")
-                    # Try to fall back to a direct file read if cluster logic is broken
-                    try:
-                        with open(os.path.join(cluster.workspace_dir, "JARVIS_CLUSTER.json"), 'r') as f:
-                            config = json.load(f)
-                    except: pass
-                
-                target_host = config.get("allocations", {}).get(guardian_id)
-                
-                if target_host and target_host != cluster.hostname:
-                    node_info = config.get("nodes", {}).get(target_host)
-                    if node_info and node_info.get("ip"):
-                        target_ip = node_info["ip"]
-                        print(f"📡 [Imperial Relay] Relaying {action} for {guardian_id} to {target_host} ({target_ip})")
-                        try:
-                            # Avoid recursive loops if somehow metadata is mixed up
-                            is_relayed = request.args.get("relayed") == "true"
-                            if not is_relayed:
-                                # Relay the POST request with the same JSON body if any
-                                relay_url = f"http://{target_ip}:18700/api/guardian/{guardian_id}/{action}"
-                                relay_resp = requests.post(relay_url, params={"relayed": "true"}, timeout=5)
-                                return jsonify(relay_resp.json()), relay_resp.status_code
-                        except Exception as relay_err:
-                            logger.error(f"🛑 [Imperial Relay] Failed to push to {target_host} ({target_ip}): {relay_err}")
-                            return jsonify({"status": "ERROR", "message": f"Cluster Relay Failed: {str(relay_err)}"}), 502
-
-            if action == 'start':
-                if full_path.endswith('.ps1'):
-                    cmd_str = f'start "{title}" powershell -NoProfile -ExecutionPolicy Bypass -File "{full_path}"'
-                else:
-                    cmd_str = f'start "{title}" cmd /c "{full_path}"'
-            else: # stop
-                if full_path.endswith('.ps1'):
-                    cmd_str = f'powershell -NoProfile -ExecutionPolicy Bypass -File "{full_path}"'
-                else:
-                    cmd_str = f'"{full_path}"'
-            
-            signal_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_SIGNAL.json")
-            data = {
-                "signal": "EXEC",
-                "content": cmd_str,
-                "sender": "Web Interface",
-                "timestamp": time.time()
-            }
-            with open(signal_file, 'w', encoding='utf-8') as f:
-                json.dump(data, f, ensure_ascii=False)
-                
-            return jsonify({"status": "SUCCESS", "message": f"{title} {action} dispatched locally."})
-
-        except Exception as e:
-            logger.error(f"🛑 [Imperial Command] execute_guardian_action failed for {guardian_id}/{action}: {e}", exc_info=True)
-            return jsonify({"status": "ERROR", "message": f"Exception: {str(e)}"}), 500
-
-
-
-    
-    @app.route('/api/todo/<todo_id>/report', methods=['PATCH'])
-    def update_report(todo_id):
-        """Update only current_action for a team task."""
-        from flask import request
-        data = request.json
-        from db_util import get_db_connection
-        conn = get_db_connection()
-        if not conn:
-            return jsonify({"status": "ERROR", "message": "DB connection failed"}), 500
-        try:
-            with conn.cursor() as cur:
-                query = 'UPDATE "taemingames"."imperial_team_tasks" SET '
-                updates = []
-                params = []
-                if "report" in data or "current_action" in data:
-                    updates.append("current_action = %s")
-                    params.append(data.get("current_action") or data.get("report"))
-                if "status" in data:
-                    updates.append("status = %s")
-                    params.append(data["status"])
-                if not updates:
-                    return jsonify({"status": "SUCCESS"})
-                updates.append("updated_at = NOW()")
-                query += ", ".join(updates) + " WHERE id = %s"
-                params.append(todo_id)
-                cur.execute(query, tuple(params))
-                conn.commit()
-            return jsonify({"status": "SUCCESS"})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-        finally:
-            conn.close()
-
-    # ===================================================================
-    # [🔱 Shadow Brain OS V2] Imperial Goal & Routine APIs
-    # ===================================================================
-
-    @app.route('/api/goals', methods=['GET'])
-    def get_imperial_goals():
-        """Retrieve all strategic goals."""
-        from db_util import get_db_connection
-        conn = get_db_connection()
-        if not conn:
-            return jsonify({"status": "ERROR", "message": "DB connection failed"}), 500
-        try:
-            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
-                cur.execute('SELECT * FROM "taemingames"."imperial_goals" ORDER BY priority DESC, created_at DESC')
-                goals = cur.fetchall()
-            return jsonify(goals)
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-        finally:
-            conn.close()
-
-    @app.route('/api/goals', methods=['POST'])
-    def create_imperial_goal():
-        """Create a new strategic goal."""
-        data = request.json
-        from db_util import get_db_connection
-        conn = get_db_connection()
-        try:
-            with conn.cursor() as cur:
-                cur.execute("""
-                    INSERT INTO "taemingames"."imperial_goals" (title, description, priority, target_date, status)
-                    VALUES (%s, %s, %s, %s, 'ACTIVE') RETURNING id
-                """, (data.get('title'), data.get('description'), data.get('priority', 0), data.get('target_date')))
-                goal_id = cur.fetchone()[0]
-                conn.commit()
-            return jsonify({"status": "SUCCESS", "id": goal_id})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-        finally:
-            conn.close()
-
-    @app.route('/api/routines', methods=['GET'])
-    def get_imperial_routines():
-        """Retrieve all automated routines."""
-        from db_util import get_db_connection
-        conn = get_db_connection()
-        try:
-            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
-                cur.execute('SELECT * FROM "taemingames"."imperial_routines" ORDER BY is_active DESC, name ASC')
-                routines = cur.fetchall()
-            return jsonify(routines)
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-        finally:
-            conn.close()
-
-    @app.route('/api/routines', methods=['POST'])
-    def create_imperial_routine():
-        """Create a new automation routine."""
-        data = request.json
-        from db_util import get_db_connection
-        conn = get_db_connection()
-        try:
-            with conn.cursor() as cur:
-                cur.execute("""
-                    INSERT INTO "taemingames"."imperial_routines" 
-                    (name, description, cron_expression, executor, goal_id, is_active)
-                    VALUES (%s, %s, %s, %s, %s, true) RETURNING id
-                """, (
-                    data.get('name'), 
-                    data.get('description'), 
-                    data.get('cron_expression'), 
-                    data.get('executor'),
-                    data.get('goal_id')
-                ))
-                routine_id = cur.fetchone()[0]
-                conn.commit()
-            return jsonify({"status": "SUCCESS", "id": routine_id})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-        finally:
-            conn.close()
-
-    @app.route('/api/routines/<routine_id>', methods=['PATCH'])
-    def update_imperial_routine(routine_id):
-        """Update or toggle a routine."""
-        data = request.json
-        from db_util import get_db_connection
-        conn = get_db_connection()
-        try:
-            with conn.cursor() as cur:
-                updates = []
-                params = []
-                for k, v in data.items():
-                    if k in ['name', 'description', 'cron_expression', 'executor', 'goal_id', 'is_active']:
-                        updates.append(f"{k} = %s")
-                        params.append(v)
-                if updates:
-                    query = f"UPDATE \"taemingames\".\"imperial_routines\" SET {', '.join(updates)} WHERE id = %s"
-                    params.append(routine_id)
-                    cur.execute(query, tuple(params))
-                    conn.commit()
-            return jsonify({"status": "SUCCESS"})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-        finally:
-            conn.close()
-
-
-
-
-    @app.route('/api/autotest', methods=['POST'])
-
-    def run_autotest():
-
-        """Signal that Jarvis should auto-test a specific todo item via browser."""
-
-        from flask import request
-
-        data = request.json or {}
-
-        todo_id = data.get("id")
-
-        signal_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_AUTOTEST.json")
-
-        try:
-
-            payload = {
-
-                "signal": "AUTOTEST",
-
-                "todo_id": todo_id,
-
-                "timestamp": time.time()
-
-            }
-
-            with open(signal_file, 'w', encoding='utf-8') as f:
-
-                json.dump(payload, f, ensure_ascii=False)
-
-            
-            # Phase 8: Logging to Imperial Neural Terminal
-            log_msg = f"🛡️ [Imperial Command] Mission {todo_id} 자비스 자율 QA 테스트 개시.."
-            print(log_msg) # This shows up in the backend console
-            return jsonify({"status": "SUCCESS", "message": "자비스 자동 테스트 신호 발송 완료"})
-        except Exception as e:
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
-    @app.route('/api/automission', methods=['POST'])
-    def run_automission():
-        """Signal that Jarvis should propose new evolution missions."""
-        signal_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_SIGNAL.json")
-        signal_data = {
-            "signal": "AUTOPROPOSE",
-            "timestamp": time.time(),
-            "sender": "Imperial Portal"
-        }
-        with open(signal_file, 'w', encoding='utf-8') as f:
-            json.dump(signal_data, f, ensure_ascii=False, indent=2)
-        return jsonify({"status": "SUCCESS", "message": "Autonomous Evolution Triggered"})
-
-
-    @app.route('/api/todo/archive', methods=['GET'])
-
-    def get_archive():
-        return jsonify([])
-    # [🔱 Imperial] System settings and voice preferences moved to chat_routes.py and admin_routes.py
-
-
-    # NOTE: The old hardcoded tts_proxy route was removed.
-
-    # The cluster-aware tts_proxy route is registered below (~line 2016).
-
-
-
-    # Initialize the Unified Brain (inside the factory function)
-
-    # Using lazy import to avoid circular dependencies if any
-
-    from brain.core import JarvisBrain
-
-    jarvis_brain = JarvisBrain()
-
-
-
-    def get_shadow_settings():
-
-        """Helper to get current brain settings."""
-
-        settings_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_SHADOW_SETTINGS.json")
-
-        if os.path.exists(settings_file):
-
-            try:
-
-                with open(settings_file, 'r', encoding='utf-8') as f:
-
-                    return json.load(f)
-
-            except: pass
-
-        return {"provider": "google", "model": "gemini-3.1-flash-lite"}
-
-
-
-    def get_brain_response_sync(prompt):
-
-        """Helper for synchronous brain calls (welcome, proactive) with multi-provider fallback."""
-
-        terminal_log = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_TERMINAL.log")
-
-        settings = get_shadow_settings()
-
-        provider = settings.get("provider", "google")
-
-        full_model = settings.get("model", "gemini-3.1-flash-lite")
-
-
-
-        def log_brain_error(pvd, mdl, err):
-
-            try:
-
-                ts = time.strftime("[%H:%M:%S]")
-
-                with open(terminal_log, 'a', encoding='utf-8') as f:
-
-                    f.write(f"{ts} [BRAIN ERROR] ({pvd}/{mdl}): {str(err)}\n")
-
-            except: pass
-
-
-
-        def try_ollama(model, p):
-
-            ollama_url = "http://localhost:11434/api/generate"
-
-            payload = {"model": model, "prompt": p, "stream": False}
-
-            try:
-
-                res = requests.post(ollama_url, json=payload, timeout=60)
-
-                res.raise_for_status()
-
-                data = res.json()
-
-                return data.get("response", "").strip() or data.get("message", {}).get("content", "").strip()
-
-            except Exception as e:
-
-                log_brain_error("ollama", model, e)
-
-                return None
-
-
-
-        def try_google(model, p):
-
-            try:
-
-                response_gen = jarvis_brain.think(p, model)
-
-                text = "".join(list(response_gen)).strip()
-
-                if not text: raise ValueError("Empty response from Google")
-
-                return text
-
-            except Exception as e:
-
-                log_brain_error("google", model, e)
-
-                return None
-
-
-
-        def try_github(model, p):
-
-            try:
-
-                token, base_url = get_github_copilot_token()
-
-                res = requests.post(f"{base_url}/chat/completions", headers={
-
-                    "Authorization": f"Bearer {token}",
-
-                    "Content-Type": "application/json",
-
-                    "Editor-Version": "vscode/1.85.1",
-
-                    "Editor-Plugin-Version": "copilot/1.138.0",
-
-                    "User-Agent": "GithubCopilot/1.138.0"
-
-                }, json={
-
-                    "messages": [{"role": "user", "content": p}],
-
-                    "model": model,
-
-                    "stream": False
-
-                }, timeout=60)
-
-                res.raise_for_status()
-
-                data = res.json()
-
-                text = data["choices"][0]["message"]["content"].strip()
-
-                if not text: raise ValueError("Empty response from GitHub")
-
-                CopilotUsageManager.track_usage(model)
-
-                return text
-
-            except Exception as e:
-
-                if "404" in str(e) or "400" in str(e):
-
-                    # Likely invalid model
-
-                    log_brain_error("github", model, f"Invalid Model? ({str(e)})")
-
-                else:
-
-                    log_brain_error("github", model, e)
-
-                return None
-
-
-
-        # Primary Attempt
-        result = None
-        if provider == "ollama":
-            result = try_ollama(full_model, prompt)
-        elif provider == "github" or provider == "copilot":
-            result = try_github(full_model, prompt)
-        elif provider == "google":
-            result = try_google(full_model, prompt)
-
-        # Fallback 시 1차 실패 후 다음 fallback provider/model 시도
-        if not result:
-            fallback_provider = settings.get("fallbackProvider", "")
-            fallback_model = settings.get("fallbackModel", "")
-            if fallback_provider and fallback_model and (fallback_provider != provider or fallback_model != full_model):
-                if fallback_provider == "google":
-                    result = try_google(fallback_model, prompt)
-                elif fallback_provider in ("github", "copilot"):
-                    result = try_github(fallback_model, prompt)
-                elif fallback_provider == "ollama":
-                    result = try_ollama(fallback_model, prompt)
-
-        return result
-
-
-
-    # ============================================================
-    # === HYDRA Proxy - Multi-Agent Browser Intelligence (Port 8002) ===
-    # ============================================================
-    @app.route('/api/hydra/mission', methods=['POST'])
-    def hydra_proxy_mission():
-        """Proxy to HYDRA Guardian: create a multi-agent browser mission."""
-        from flask import request, jsonify
-        data = request.json or {}
-        command = data.get("command", "")
-        max_agents = data.get("max_agents", 2)
-        if not command:
-            return jsonify({"error": "command is required"}), 400
-        try:
-            res = requests.post("http://localhost:8002/hydra/mission",
-                json={"command": command, "max_agents": max_agents},
-                timeout=120)
-            return jsonify(res.json()), res.status_code
-        except requests.exceptions.ConnectionError:
-            return jsonify({"error": "HYDRA Guardian is offline. Start it with RunHydra.bat"}), 503
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/hydra/mission/<int:mission_id>', methods=['GET'])
-    def hydra_proxy_get_mission(mission_id):
-        """Proxy to HYDRA Guardian: get mission result."""
-        try:
-            res = requests.get(f"http://localhost:8002/hydra/mission/{mission_id}", timeout=30)
-            return jsonify(res.json()), res.status_code
-        except requests.exceptions.ConnectionError:
-            return jsonify({"error": "HYDRA Guardian is offline"}), 503
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/hydra/health', methods=['GET'])
-    def hydra_proxy_health():
-        """Proxy to HYDRA Guardian: health check."""
-        try:
-            res = requests.get("http://localhost:8002/api/health", timeout=5)
-            return jsonify(res.json()), res.status_code
-        except requests.exceptions.ConnectionError:
-            return jsonify({"guardian": "HYDRA", "status": "offline"}), 503
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/shadow/hydra-callback/<task_id>', methods=['POST'])
-    def hydra_dispatch_callback(task_id):
-        """
-        🐉 HYDRA v4.0 콜백 핸들러
-        히드라 자율 처리 완료 후 도착한 최종 합성 결과와 태스크들을 DB에 기록합니다.
-        """
-        from flask import request, jsonify
-        from db_util import get_db_connection
-        
-        data = request.json or {}
-        dispatch_id = data.get("dispatch_id", "UNKNOWN")
-        synthesis = data.get("synthesis", "")
-        status = data.get("status", "complete")
-        results = data.get("results", [])
-        
-        from engines.hydra import hydra_director
-        print(f"🐉 [HYDRA Callback {dispatch_id}] Task {task_id} 결과 수신 완료 ({len(results)}개 작업)")
-        
-        # [🔱 Imperial] 오케스트레이터 로그 기록
-        hydra_director._log_to_db(task_id, f"📡 히드라 서버로부터 분석 보고서가 도착했습니다. ({status})")
-        if synthesis:
-            hydra_director._log_to_db(task_id, f"📝 요약: {synthesis[:200]}...")
-
-        try:
-            conn = get_db_connection()
-            cur = conn.cursor()
-            
-            # 1. 태스크 상태 및 결과물(synthesis) 업데이트
-            import json
-            cur.execute("""
-                UPDATE taemingames.imperial_team_tasks
-                SET status = 'UNDER_REVIEW',
-                    test_result = %s,
-                    current_action = '[HydraRunner] 자율 기획 합성 완료'
-                WHERE id = %s
-            """, (json.dumps(synthesis), task_id))
-            
-            conn.commit()
-            cur.close()
-            conn.close()
-            
-            # 2. 하위 태스크(Actual Work) 생성
-            if results:
-                print(f"🐉 [HYDRA Callback] {len(results)}개의 서브태스크 생성을 시작합니다.")
-                hydra_director._log_to_db(task_id, f"⚔️ {len(results)}개의 분과별 세부 명령을 하달합니다.")
-                try:
-                    hydra_director._create_team_tasks(task_id, results)
-                    hydra_director._log_to_db(task_id, f"✅ {len(results)}개의 서브태스크가 대시보드에 편성되었습니다.")
-                except Exception as e_create:
-                    logger.error(f"[HYDRA Callback] 하위 태스크 생성 실패: {e_create}")
-                    hydra_director._log_to_db(task_id, f"❌ 하위 태스크 생성 중 오류: {str(e_create)}", "ERROR")
-            else:
-                print(f"⚠️ [HYDRA Callback] 수신된 서브태스크 결과가 없습니다.")
-                hydra_director._log_to_db(task_id, "⚠️ 수신된 서브태스크 결과가 없습니다.")
-                hydra_director._log_to_db(task_id, "✅ 모든 수호자가 명령을 수령했습니다. 작업을 개시합니다.")
-            
-            return jsonify({"status": "acknowledged", "task_id": task_id}), 200
-            
-        except Exception as e:
-            print(f"❌ [HYDRA Callback] DB 업데이트 실패: {e}")
-            return jsonify({"error": str(e)}), 500
-
-    # ============================================================
-    # 🎭 제국 전문 스튜디오 (Imperial Studio) — 재설계 v2.0
-    #  - 흐름: 스토리 우선 생성 → 스토리에 맞는 배우 배정
-    #  - 집필 수호자(script_writer_guardian_id)의 페르소나/���능을 실제 적용
-    # ============================================================
-
-    def _studio_load_writer_persona(guardian_id):
-        """집필 수호자 페르소나(이름/설명/지능)를 DB에서 로드한다.
-        실패하거나 guardian_id가 없으면 None을 반환해 기본 집필자로 폴백한다."""
-        if not guardian_id:
-            return None
-        try:
-            conn = psycopg2.connect(DB_URL)
-            cur = conn.cursor()
-            cur.execute(
-                """
-                SELECT name, canonical_name, description, ai_provider, ai_model, temperature
-                FROM taemingames.guardian_personas
-                WHERE id::text = %s OR canonical_name = %s OR name = %s
-                LIMIT 1
-                """,
-                (str(guardian_id), str(guardian_id), str(guardian_id)),
-            )
-            row = cur.fetchone()
-            cur.close()
-            conn.close()
-            if not row:
-                return None
-            return {
-                "name": row[0],
-                "canonical_name": row[1],
-                "description": row[2] or "",
-                "provider": row[3],
-                "model": row[4],
-                "temperature": row[5],
-            }
-        except Exception as e:
-            logging.warning(f"[Studio] 집필 수호자 로드 실패({guardian_id}): {e}")
-            return None
-
-    def _studio_assign_voice(member, engine):
-        """배우 1명에게 엔진에 맞는 보이스를 할당한다 (in-place)."""
-        name_str = str(member.get("name", "")).lower()
-        gender = str(member.get("gender", "female")).lower()
-        if engine == "orpheus":
-            if gender == "male":
-                if any(k in name_str for k in ["자비스", "아이젠", "길가메쉬", "후긴", "바하무트"]):
-                    member["voice"] = "ryan"
-                elif any(k in name_str for k in ["장인", "촌장", "마법사", "장로"]):
-                    member["voice"] = "uncle_fu"
-                else:
-                    member["voice"] = "aiden"
-            else:
-                member["voice"] = "sohee"
-        else:
-            try:
-                member["voice"] = gemini_audio.auto_match_voice(member.get("name", ""), gender)
-            except Exception:
-                member["voice"] = "Zephyr"
-        return member
-
-    def _studio_extract_speakers(script):
-        """완성된 대본에서 등장하는 화자 이름을 등장 순서대로(중복 제거) 추출한다.
-        대본 형식은 '이름: (감정) 대사' 이므로 콜론 앞 토큰을 화자로 본다."""
-        import re as _re
-        speakers = []
-        seen = set()
-        for raw in (script or "").splitlines():
-            line = raw.strip()
-            if not line or ":" not in line:
-                continue
-            name = line.split(":", 1)[0].strip()
-            # 감정 괄호가 이름 쪽에 붙은 경우 제거: "자비스 (비장하게)" -> "자비스"
-            name = _re.sub(r"[\(\[（【].*$", "", name).strip()
-            # 화자 이름은 짧아야 한다(서술/지문 라인의 콜론 오인 방지)
-            if not name or len(name) > 20:
-                continue
-            # 명백한 지문/메타 라인 배제
-            if any(bad in name for bad in ["[", "씬", "장면", "Scene", "내레이션", "나레이션"]):
-                continue
-            key = name.lower()
-            if key not in seen:
-                seen.add(key)
-                speakers.append(name)
-        return speakers
-
-    @app.route('/api/shadow/audio/studio/prepare', methods=['POST'])
-    def studio_prepare():
-        """🎭 배우 배정(캐스팅).
-        - script가 주어지면: 완성된 스토리를 분석해 실제 등장인물을 배우로 배정한다 (스토리→배우).
-        - script가 없으면: 주제만으로 3~5명의 배우를 임시 구성한다 (레거시 폴백)."""
-        data = request.json or {}
-        topic = data.get("topic", "제국의 일상")
-        script = data.get("script", "")
-        engine = data.get("engine", "gemini")
-
-        writer_id = data.get("script_writer_guardian_id")
-        persona = _studio_load_writer_persona(writer_id)
-        script_provider = data.get("script_provider") or (persona or {}).get("provider") or "google"
-        script_model = data.get("script_model") or (persona or {}).get("model") or (
-            jarvis_brain.primary_model if jarvis_brain else "gemini-3.1-flash-lite"
-        )
-        def _studio_raise_on_error(text):
-            """브레인 OpenAI 호환 경로는 연결 실패 시 '❌ ... 오류' 텍스트를 반환한다.
-            폴백 없이 실제 에러를 그대로 드러내기 위해 예외로 승격한다."""
-            if any(m in text for m in ("❌", "Connection refused", "Max retries", "Failed to establish")):
-                raise RuntimeError(text.strip())
-
+        # Imperial Token 검증
+        token = request.headers.get('X-Imperial-Token') or request.headers.get('X-Guardian-Token')
+        expected = os.environ.get('IMPERIAL_API_TOKEN') or os.environ.get('GUARDIAN_SERVICE_TOKEN', '')
+        if expected and token != expected:
+            return jsonify({'error': 'Unauthorized'}), 401
+        data = request.get_json(force=True, silent=True) or {}
+        message = data.get('message', '')
+        user_name = data.get('user_name', '사용자')
+        user_id = data.get('user_id', '')
+        username = data.get('username', '')
+        source = data.get('source', 'unknown')
+        context_id = data.get('context_id') or f"{source}:{user_id}"
+        is_registered = data.get('is_registered', False)
+        role = data.get('role', 'guest')
+        skip_grounding = data.get('skipGrounding') is True
+        if not message:
+            return jsonify({'error': 'message required'}), 400
         try:
-            cast = []
-
-            if script and script.strip():
-                # 스토리 → 배우: 대본에서 실제 화자를 뽑고, 각 인물의 성별/배역을 LLM으로 판단
-                names = _studio_extract_speakers(script)
-                if names:
-                    name_list = ", ".join(names)
-                    prompt = f"""다음은 완성된 연극 대본입니다. 이 대본에 실제로 등장하는 인물 목록은 아래와 같습니다.
-등장인물: {name_list}
-
-각 인물에 대해 대본 내용에 근거하여 성별(male 또는 female)과 한 줄 배역 설명(role)을 판단하세요.
-반드시 아래 형식의 JSON 배열만 출력하세요. 다른 설명은 절대 붙이지 마세요.
-[
-  {{"name": "<목록에 있는 이름 그대로>", "gender": "male", "role": "배역 설명"}}
-]
-
-[대본]
-{script}
-"""
-                    response_text = ""
-                    for chunk in jarvis_brain.think(
-                        prompt, model_name=script_model, provider=script_provider,
-                        system_instruction="You are the Imperial Studio Casting Director. Output ONLY valid raw JSON.",
-                        skip_tools=True,
-                    ):
-                        if chunk.strip().startswith('[SYSTEM]'):
-                            continue
-                        response_text += chunk
-                    _studio_raise_on_error(response_text)
-                    import re
-                    json_match = re.search(r'\[.*\]', response_text, re.DOTALL)
-                    parsed = json.loads(json_match.group() if json_match else response_text)
-                    # 추출된 이름 순서를 기준으로 정렬/보정
-                    by_name = {str(p.get("name", "")).strip(): p for p in parsed if isinstance(p, dict)}
-                    for n in names:
-                        p = by_name.get(n) or {}
-                        cast.append({
-                            "name": n,
-                            "gender": str(p.get("gender", "female")).lower(),
-                            "role": p.get("role", ""),
-                        })
-
-            if not cast and not (script and script.strip()):
-                # 대본이 아예 없을 때만 주제 기반 캐스팅 (폴백 아님)
-                prompt = f"""주제: {topic}
-
-위 주제에 가장 잘 어울리는 제국 세계관의 등장인물(영웅/배역)을 3명에서 5명 사이로 구성하세요.
-각 인물마다 다음을 지정하세요.
-1. name: 인물 이름 (예: 자비스, 아이젠, 신비로운 현자)
-2. gender: male 또는 female
-3. role: 역할/성격 한 줄 설명
-
-반드시 아래 형식의 JSON 배열만 출력하세요. 다른 설명은 절대 붙이지 마세요.
-[
-  {{"name": "...", "gender": "male", "role": "..."}}
-]
-"""
-                response_text = ""
-                for chunk in jarvis_brain.think(
-                    prompt, model_name=script_model, provider=script_provider,
-                    system_instruction="You are the Imperial Studio Director. Output ONLY valid raw JSON.",
-                    skip_tools=True,
-                ):
-                    if chunk.strip().startswith('[SYSTEM]'):
-                        continue
-                    response_text += chunk
-                _studio_raise_on_error(response_text)
-                import re
-                json_match = re.search(r'\[.*\]', response_text, re.DOTALL)
-                cast = json.loads(json_match.group() if json_match else response_text)
-
-            # 보이스 자동 할당
-            for member in cast:
-                if not isinstance(member, dict):
-                    continue
-                _studio_assign_voice(member, engine)
-
-            return jsonify({"status": "success", "cast": cast})
-        except Exception as e:
-            logging.error(f"[Studio] Prepare failed: {e}")
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/shadow/audio/studio/script', methods=['POST'])
-    def studio_script():
-        """🎭 대본 집필 (스토리 우선).
-        - cast가 비어 있으면(자동 캐스팅): 집필 ���호자가 주제에 맞는 스토리를 먼저 구상하고
-          그 스토리에 어울리는 3~5명의 등장인물을 스스로 창조하여 대본을 쓴다.
-        - cast가 주어지면(수호자 캐스팅): 지정된 배우들로 대본을 쓴다.
-        - 집필 수호자(script_writer_guardian_id)의 페르소나/문체/지능을 적용한다."""
-        data = request.json or {}
-        topic = data.get("topic", "")
-        cast = data.get("cast", [])
-        duration = data.get("duration", 1)
-        audio_engine = data.get("engine", "orpheus")
-
-        writer_id = data.get("script_writer_guardian_id")
-        persona = _studio_load_writer_persona(writer_id)
-        script_provider = data.get("script_provider") or (persona or {}).get("provider") or "google"
-        script_model = data.get("script_model") or (persona or {}).get("model") or (
-            jarvis_brain.primary_model if jarvis_brain else "gemini-3.1-flash-lite"
-        )
-
-        # 집필 분량 (한국어 대사 기준 분당 약 400자)
-        target_length = int(duration) * 400
-
-        # 집필 수호자 페르소나를 시스템 지시로 주입
-        if persona and persona.get("description"):
-            writer_name = persona.get("canonical_name") or persona.get("name") or "집필 수호자"
+            # 🔱 [페르소나 SSOT] provider/model은 전역 JSON이 아니라 대상 수호자
+            # 페르소나(guardian_personas)에서 가져온다. think(target_persona_id=...)가
+            # Aegis /api/neural/identity 로 ai_provider/relay_model 을 해석한다.
+            # (direct/chat 과 동일한 페르소나 기반 신원 해석)
+            target_guardian = data.get('target_guardian') or 'shadow_brain'
+            aegis_url = request.headers.get('X-Aegis-URL')
+            user_display = user_name
+            if username:
+                user_display += f"(@{username})"
+            # 헤임달 가입 여부에 따라 시스템 프롬프트 차별화
+            if is_registered and role in ('Master', 'Admin'):
+                identity_line = (
+                    f"대화 상대는 제국 마왕 '{user_display}'님입니다. 헤임달 인증 계정({role})으로 확인된 최고 권위자입니다.\n"
+                    "최고의 경의와 충성으로 보좌하십시오."
+                )
+            elif is_registered:
+                identity_line = (
+                    f"대화 상대는 헤임달 인증 계정({role})을 보유한 '{user_display}'님입니다.\n"
+                    "신뢰할 수 있는 제국 구성원으로 예우하십시오."
+                )
+            else:
+                identity_line = (
+                    f"대화 상대는 '{user_display}'님이며, 현재 헤임달 미가입 외부 접속자입니다.\n"
+                    "정중하게 응대하되, 제국 내부 정보는 제한적으로 공개하십시오.\n"
+                    "반드시 응답 말미에 자연스럽게 한 번만 언급하십시오: "
+                    "헤임달에 텔레그램으로 계정을 생성하면 저와의 대화가 기억으로 연결됩니다."
+                )
             system_instruction = (
-                f"당신은 제국 전문 스튜디오의 집필 수호자 '{writer_name}'입니다. "
-                f"다음은 당신의 정체성과 문체입니다:\n{persona['description']}\n\n"
-                "이 정체성과 문체를 유지한 채로, 요청된 연극 대본을 집필하세요."
+                f"당신은 중앙 관제 인공지능 '쉐도우브레인(ShadowBrain)'입니다.\n"
+                f"{identity_line}\n"
+                f"대화 중 자연스럽게 '{user_name}'님의 이름을 불러주십시오.\n"
+                "말투는 매우 정중하고 예의를 갖추되, 제국 사령관으로서의 권위와 압도적인 지능이 느껴져야 합니다.\n"
+                "한국어로 응답하며, 가끔 '🔱' 또는 '👑' 이모지를 섞어 제국의 위엄을 표기하십시오.\n"
+                "지시는 짧고 명확하게, 설명은 품격 있게 하십시오."
             )
-        else:
-            system_instruction = "당신은 제국 전문 스튜디오의 수석 극작가입니다. 몰입감 있고 드라마틱한 연극 대본을 집필하세요."
-
-        # 출연진 구성 / 자동 창작 분기
-        if cast:
-            cast_desc = "\n".join(
-                [f"- {m.get('name')} ({m.get('gender', 'female')}, {m.get('role', '')})" for m in cast]
+            # 🔱 [도구 사용] 단발 호출(_call_provider) 대신 think 경로로 전환.
+            # stream=False → interactive=False 자동 적용 → 웹검색 등 도구는 돌되
+            # ask_user(선택 카드)는 자동 차단되어 텍스트로 강등된다.
+            # (헤임달 직통 채널 /api/shadow/direct/chat 은 stream=True라 영향 없음)
+            from services.brain_service import think as _think
+            _result = _think(
+                message,
+                stream=False,
+                target_persona_id=target_guardian,
+                system_instruction=system_instruction,
+                token=expected,
+                aegis_url=aegis_url,
+                context_id=context_id,
+                skip_grounding=skip_grounding,
             )
-            cast_block = f"""출연진(이 인물들만 사용하세요):
-{cast_desc}
-
-위 출연진 전원이 각자의 개성에 맞춰 골고루 등장해야 합니다."""
-        else:
-            cast_block = """먼저 주제에 가장 잘 어울리는 한 편의 스토리를 머릿속으로 구상하세요.
-그 스토리에 가장 자연스럽게 어울리는 등장인물 3~5명을 직접 창조하여 배역으로 삼으세요.
-각 인물은 뚜렷한 개성과 목소리를 가져야 하며, 이야기 안에서 균형 있게 등장해야 합니다."""
-
-        if audio_engine == "gemini":
-            # Gemini TTS는 풍부한 감정 태그를 지원
-            fmt_rules = """[작성 규칙]
-1. 형식: "이름: (감정) 대사" — 한 줄에 한 명의 대사.
-2. 감정 태그를 다양하게 사용: (비장하게), (다정하게), (단호하게), (환희에 차), (분노하며), (속삭이듯) 등.
-3. 줄마다 반드시 화자 이름으로 시작하고, 콜론 뒤에 (감정) 대사를 적으세요.
-4. 지문/장면 설명은 넣지 말고 오직 대사 줄만 출력하세요."""
-        else:
-            # Orpheus(Qwen3-TTS)는 감정 태그를 처리하지 못함 — 순수 대사만
-            fmt_rules = """[작성 규칙]
-1. 형식: "이름: 대사" — 한 줄에 한 명의 대사. (감정 괄호 표현은 절대 사용하지 마세요.)
-2. 감정과 분위기는 대사 문장과 말투 자체로 자연스럽게 표현하세요.
-3. 줄마다 반드시 화자 이름으로 시작하고, 콜론 뒤에 대사를 적으세요.
-4. 지문/장면 설명은 넣지 말고 오직 대사 줄만 출력하세요."""
-
-        prompt = f"""주제: {topic}
-목표 분량: 약 {duration}분 (한국어 약 {target_length}자 내외)
-
-{cast_block}
-
-위 내용으로 몰입감 있고 드라마틱한 연극 대본을 작성해 주세요.
-전체 대본 길이는 {target_length}자 안팎으로 충분히 길고 풍부하게 구성하세요.
-
-{fmt_rules}
-
-대본:
-"""
-
-        def generate():
-            # 폴백 없음 — 집필 수호자의 지능 엔진을 그대로 호출하고, 실패하면 실제 에러를 그대로 스트리밍한다.
-            # (브레인 OpenAI 호환 경로는 연결 실패 시 '❌ ... 오류: <원문>' 텍스트를 yield 하므로 그대로 노출됨)
-            try:
-                for chunk in jarvis_brain.think(
-                    prompt, model_name=script_model, provider=script_provider,
-                    system_instruction=system_instruction, skip_tools=True,
-                ):
-                    if chunk.strip().startswith('[SYSTEM]'):
-                        continue
-                    yield chunk
-            except Exception as e:
-                logging.error(f"[Studio] 집필 실패: {e}")
-                yield f"❌ [집필 실패] {type(e).__name__}: {str(e)}"
-
-        return Response(stream_with_context(generate()), content_type='text/plain; charset=utf-8')
-
-    @app.route('/api/shadow/audio/studio/save', methods=['POST'])
-    def studio_save():
-        """Step 3: Save the studio session library."""
-        data = request.json or {}
-        session_id = data.get("session_id")
-        title = data.get("title") or data.get("topic", "Untitled")
-        cast = data.get("cast", [])
-        script = data.get("script", "")
-        duration = data.get("duration", 1)
-        audio_base64 = data.get("audio_base64")
-        casting_mode = data.get("casting_mode", "auto")
-        selected_guardians = data.get("selected_guardians", [])
-        portrait_overrides = data.get("portrait_overrides", {})
-
-        def _studio_root_dir():
-            return os.path.join(project_root, "docker_data", "shared_workspace", "Dialogue")
-
-        def _studio_session_dir():
-            return os.path.join(_studio_root_dir(), "Studio")
-        
-        try:
-            studio_dir = _studio_session_dir()
-            os.makedirs(studio_dir, exist_ok=True)
-            
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            
-            if session_id:
-                # Use existing session ID if provided (Overwrite mode)
-                base_name = session_id
-            else:
-                # Generate new ID based on title (New save mode)
-                safe_title = "".join([c for c in title if c.isalnum() or c in (' ', '_')]).rstrip()[:30]
-                base_name = f"Studio_{timestamp}_{safe_title}"
-            
-            # Save Metadata + Script + Cast + Duration
-            save_data = {
-                "title": title,
-                "timestamp": timestamp,
-                "cast": cast,
-                "script": script,
-                "duration": duration,
-                "version": "1.2",
-                "casting_mode": casting_mode,
-                "selected_guardians": selected_guardians,
-                "portrait_overrides": portrait_overrides,
-            }
-            with open(os.path.join(studio_dir, f"{base_name}.json"), "w", encoding="utf-8") as f:
-                json.dump(save_data, f, ensure_ascii=False, indent=2)
-            
-            # Save Audio if provided
-            if audio_base64:
-                import base64
-                with open(os.path.join(studio_dir, f"{base_name}.mp3"), "wb") as f:
-                    f.write(base64.b64decode(audio_base64))
-            
-            return jsonify({"status": "success", "session_id": base_name})
+            _raw_reply = _result.get("text", "") if isinstance(_result, dict) else str(_result)
+            # 🖼️ A2UI 카드 블록(imperial-media/youtube/ask 등)은 디스코드/텔레그램이
+            # 렌더링 못 하므로, 블록 안의 URL만 추출해 평문으로 강등(디스코드 자동 임베드).
+            reply = _sanitize_a2ui_for_relay(_raw_reply)
+            if not reply:
+                reply = _raw_reply
+            user_label = f"{user_name}"
+            if username:
+                user_label += f" (@{username})"
+            if user_id:
+                user_label += f" [{user_id}]"
+            reg_tag = f"✅{role}" if is_registered else "❌미가입"
+            logger.info(f"[📱 {source.upper()}] [{user_label}] ({reg_tag}): {message}")
+            logger.info(f"[📱 {source.upper()}] [ShadowBrain persona={target_guardian}]: {reply}")
+            return jsonify({'reply': reply, 'target_guardian': target_guardian})
         except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    STUDIO_IMAGE_QUOTA_FILE = os.path.join(project_root, "docker_data", "shared_workspace", "studio_image_quota.json")
-    STUDIO_IMAGE_LIMITS = {
-        "imagen-4.0-generate-001": 70,
-        "imagen-4.0-fast-generate-001": 70,
-        "gemini-2.0-flash": 2000,
-        "gemini-3.1-flash-image-preview": 1000,
-        "gemini-3-pro-image-preview": 250
-    }
-
-    def _load_image_quota():
-        import json
-        from datetime import datetime
-        current_date = datetime.now().strftime('%Y-%m-%d')
-        try:
-            with open(STUDIO_IMAGE_QUOTA_FILE, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            if data.get('date') != current_date:
-                data = {'date': current_date, 'usage': {}}
-                _save_image_quota(data)
-            return data
-        except (FileNotFoundError, json.JSONDecodeError):
-            data = {'date': current_date, 'usage': {}}
-            _save_image_quota(data)
-            return data
-
-    def _save_image_quota(data):
-        import json
-        os.makedirs(os.path.dirname(STUDIO_IMAGE_QUOTA_FILE), exist_ok=True)
-        with open(STUDIO_IMAGE_QUOTA_FILE, 'w', encoding='utf-8') as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-
-    def _increment_image_quota(api_model):
-        data = _load_image_quota()
-        if 'usage' not in data:
-            data['usage'] = {}
-        data['usage'][api_model] = data['usage'].get(api_model, 0) + 1
-        _save_image_quota(data)
-
-    @app.route('/api/studio/quota', methods=['GET'])
-    def get_studio_quota():
-        """이미지 생성 쿼터 상태 반환"""
-        data = _load_image_quota()
-        usage = data.get('usage', {})
-        result = {}
-        for api_model, limit in STUDIO_IMAGE_LIMITS.items():
-            used = usage.get(api_model, 0)
-            result[api_model] = {"used": used, "limit": limit}
-        return jsonify({"status": "success", "quota": result})
-
-    @app.route('/api/studio/image-models', methods=['GET'])
-    def studio_image_models():
-        """지원되는 이미지 생성 모델 리스트를 반환."""
-        models = [
-            {
-                "id": "imagen-4.0-generate-001",
-                "name": "Imagen 4.0",
-                "description": "사실적이고 고품질의 이미지 생성에 최적화된 구글의 최신 모델입니다.",
-                "type": "predict",
-                "apiModel": "imagen-4.0-generate-001"
-            },
-            {
-                "id": "nano-banana",
-                "name": "나노바나나(Nano Banana)",
-                "description": "빠르고 효율적인 이미지 생성과 창의적인 비전을 구현에 적합합니다.",
-                "type": "generateContent",
-                "apiModel": "gemini-2.0-flash"
-            },
-            {
-                "id": "nano-banana-2",
-                "name": "나노바나나 2",
-                "description": "Gemini 3.1 Flash 기반으로 더욱 향상된 디테일과 정상적 프롬프트 이해력을 제공합니다.",
-                "type": "generateContent",
-                "apiModel": "gemini-3.1-flash-image-preview"
-            },
-            {
-                "id": "nano-banana-pro",
-                "name": "나노바나나 Pro",
-                "description": "Gemini 3 Pro 기반의 최상위 영상미와 복잡한 구도를 처리하는 전문가 모델입니다.",
-                "type": "generateContent",
-                "apiModel": "gemini-3-pro-image-preview"
-            },
-            {
-                "id": "imagen-4.0-fast-generate-001",
-                "name": "Imagen 4.0 Fast",
-                "description": "빠르고 창의적인 고품질의 이미지 생성에 최적화된 최신 경량 모델입니다.",
-                "type": "predict",
-                "apiModel": "imagen-4.0-fast-generate-001"
-            }
-        ]
-        return jsonify({"status": "success", "models": models})
-
-    def _upload_studio_image_to_r2(local_path, filename):
-        """🔱 생성된 스튜디오 이미지를 R2(Live)에 업로드하고 공개 URL을 반환한다.
-        배포 환경(HF/gunicorn)은 로컬 디스크가 휘발성이라 R2 영속화가 필수다.
-        업로드 실패 시 None을 반환하여 호출부가 로컬 경로로 폴백하게 한다."""
-        try:
-            # [🔱 진단] 업로드 전 R2 Live 자격증명을 먼저 검증한다. 배포 환경에
-            # R2_LIVE_ACCOUNT / R2_LIVE_ACCESS_KEY_ID / R2_LIVE_SECRET_ACCESS_KEY 가
-            # 누락되면 put_object가 조용히 실패하므로, 원인을 로그로 명확히 남긴다.
-            _cfg = cloud_tool.R2_ACCOUNTS.get("live", {})
-            _missing = [
-                k for k in ("account_id", "access_key_id", "secret_access_key")
-                if not cloud_tool._get_bw_credential(_cfg.get(k))
-            ]
-            if _missing:
-                logging.error(
-                    "[Studio R2] R2 Live 자격증명 누락 → 로컬 폴백. "
-                    "배포 환경에 다음 환경변수를 설정하십시오: "
-                    "R2_LIVE_ACCOUNT, R2_LIVE_ACCESS_KEY_ID, R2_LIVE_SECRET_ACCESS_KEY "
-                    f"(미해결 필드: {_missing})"
-                )
-                return None
-            r2_key = f"studio/generated/{filename}"
-            uploader = ImperialR2Uploader("live")
-            res = uploader.upload(local_path, r2_key)
-            # upload()는 DB 인덱싱까지 성공해야 url을 주지만, R2 객체 업로드 자체는
-            # 그 이전에 끝난다. 인덱싱이 실패해도 공개 URL은 직접 조립해 반환한다.
-            if res.get("success") and res.get("url"):
-                logging.info(f"[Studio R2] Upload+index success: {res['url']}")
-                return res["url"]
-            # 업로드 자체가 실패(객체가 R2에 없음)면 폴백 URL을 만들면 안 된다.
-            err = str(res.get("error", ""))
-            if err.startswith("Boto3 Upload") or err.startswith("Source not found"):
-                logging.error(f"[Studio R2] Object upload failed: {err}")
-                return None
-            # 객체 업로드는 끝났고 DB 인덱싱만 실패한 경우엔 공개 URL을 직접 조립해 반환
-            public_url = f"{uploader.public_url_base}/{r2_key}"
-            logging.warning(f"[Studio R2] Index step failed but object uploaded; using {public_url} ({err})")
-            return public_url
-        except Exception as r2_err:
-            logging.error(f"[Studio R2] Upload failed for {filename}: {r2_err}")
-            return None
+            logger.error(f"[Telegram Relay Chat] Error: {e}")
+            return jsonify({'error': str(e)}), 500
 
-    @app.route('/api/studio/generate-image', methods=['POST'])
-    def studio_generate_image():
-        """구글 GenAI 모델 또는 헤파이스토스(로컬 엔진)를 사용하여 이미지 생성."""
-        data = request.json or {}
-        engine = data.get("engine", "gemini")
-        prompt = data.get("prompt")
-        model_id = data.get("model_id", "imagen-4.0-generate-001")
-        aspect_ratio = data.get("aspect_ratio", "1:1")
-        
-        if not prompt:
-            return jsonify({"error": "prompt is required"}), 400
+    # --- Guardian Startup Config API ---
+    @app.route('/api/config/startup', methods=['GET', 'POST', 'OPTIONS'])
+    @app.route('/api/shadow/startup', methods=['GET', 'POST', 'OPTIONS'])
+    def handle_startup_config():
+        """Handles Imperial Guardian Startup configuration (Unified)."""
+        if request.method == 'OPTIONS':
+            return jsonify({}), 200
             
-        gen_dir = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "generated_images")
-        os.makedirs(gen_dir, exist_ok=True)
+        config_path = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_STARTUP_CONFIG.json")
         
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        unique_id = f"{timestamp}_{random.randint(1000, 9999)}"
-        filename = f"gen_{engine}_{unique_id}.png"  # will be renamed if needed
-        output_file = os.path.join(gen_dir, filename)
+        # [Imperial Standard] Full Guardian Template for UI (13 Guardians)
+        DEFAULT_STARTUP = {
+            "core": {"ether": True, "drako": True},
+            "media": {"orpheus": True, "wan2gp": True},
+            "interface": {"heimdall": True, "ether_portal": True},
+            "guardians": {
+                "drako": True,
+                "bahamut": True,
+                "iris": True,
+                "orpheus": True,
+                "wan2gp": True,
+                "heimdall": True,
+                "tiamat": False,
+                "hydra": False,
+                "aizen": False,
+                "hugin": False,
+                "hermes": False,
+                "bastion": True,
+                "atlas": True,
+                "shadow_brain": True,
+                "shadow_rust_brain": True,
+                "pandora": True
+            }
+        }
         
-        # --- 헤파이스토스(Z-Image, Flux1 등) 엔진 처리 로직 ---
-        if engine.lower() == "hephaestus":
-            if not _hephaestus_online():
-                return jsonify({"error": "헤파이스토스(8001포트) 엔진이 현재 오프라인 상태입니다."}), 503
-            
-            try:
-                import glob
-                import shutil
-                
-                req_json_path = os.path.join(project_root, "wan2gp", "temp_jarvis_req.json")
-                out_dir_host = os.path.join(project_root, "docker_data", "wan2gp_workspace", "outputs")
-                
-                # 이미지 생성용 기본 해상도 (정사각형 기본)
-                if aspect_ratio == "16:9": resolution = "1280x720"
-                elif aspect_ratio == "9:16": resolution = "720x1280"
-                else: resolution = "1024x1024"  # 1:1 and default -> square image
-                
-                # Z-Image 이미지 생성 파라미터 (z_image_base_settings.json 기준)
-                # guidance_scale=0 + NAG 파라미터 조합은 비디오 모드를 트리거하므로 사용 금지
-                payload = {
-                    "settings_version": 2.55,
-                    "model_type": model_id,
-                    "prompt": prompt,
-                    "resolution": resolution,
-                    "flow_shift": 6.0,
-                    "guidance_scale": 4,
-                    "num_inference_steps": 30,
-                    "batch_size": 1
-                }
-                
-                with open(req_json_path, "w", encoding="utf-8") as f:
-                    json.dump(payload, f, indent=4, ensure_ascii=False)
-                
-                # Run Headless CLI inside WanGP Docker
-                cmd = [
-                    "docker", "exec", "-u", "user", "wan2gp-service",
-                    "python3", "wgp.py", "--process", "temp_jarvis_req.json", "--output-dir", "outputs"
-                ]
+        try:
+            if request.method == 'GET':
+                if not os.path.exists(config_path):
+                    return jsonify(DEFAULT_STARTUP)
                 
-                # [🔱 v2.8.1] 5분(300초) 타임아웃 부여하여 Blackwell 환경 등에서 이미지/영상 연성 행잉 시 서버 무한 대기 방지
                 try:
-                    result = subprocess.run(cmd, capture_output=True, text=True, cwd=os.path.join(project_root, "wan2gp", encoding='utf-8', errors='replace'), encoding='utf-8', errors='replace', timeout=300)
-                except subprocess.TimeoutExpired:
-                    logging.error("Hephaestus Generation Timeout (300s expired)")
-                    return jsonify({"error": "헤파이스토스 연성 시간이 초과되었습니다 (300초). GPU 부하 또는 Blackwell 호환성 문제를 확인하십시오."}), 504
-                
-                if result.returncode != 0:
-                    logging.error(f"Hephaestus Docker CLI Error: {result.stderr}")
-                    return jsonify({"error": f"헤파이스토스 CLI 실행 실패: {result.stderr[-200:] if result.stderr else 'Unknown Error'}"}), 500
+                    with open(config_path, 'r', encoding='utf-8') as f:
+                        config = json.load(f)
                     
-                # Find the newest generated file in outputs (image OR video)
-                output_files = (
-                    glob.glob(os.path.join(out_dir_host, "*.jpg")) +
-                    glob.glob(os.path.join(out_dir_host, "*.png")) +
-                    glob.glob(os.path.join(out_dir_host, "*.mp4"))
-                )
-                if not output_files:
-                    return jsonify({"error": "헤파이스토스 생성 후 결과 파일을 찾지 못했습니다. outputs 디렉터리를 확인하세요."}), 500
-                
-                newest_file = max(output_files, key=os.path.getctime)
-                
-                # Rename filename to match actual extension
-                actual_ext = os.path.splitext(newest_file)[1]  # e.g. '.mp4' or '.png'
-                filename = f"gen_{engine}_{unique_id}{actual_ext}"
-                output_file = os.path.join(gen_dir, filename)
-                
-                # Move the file to Jarvis generated_images cache
-                shutil.move(newest_file, output_file)
-                
-                # Clean up json template
-                try: os.remove(req_json_path)
-                except: pass
+                    # Ensure 'guardians' exists for UI stability
+                    if "guardians" not in config:
+                        config["guardians"] = DEFAULT_STARTUP["guardians"]
+                    else:
+                        # [Self-healing] Auto-merge missing guardians from standard template
+                        for k, v in DEFAULT_STARTUP["guardians"].items():
+                            if k not in config["guardians"]:
+                                config["guardians"][k] = v
+                    return jsonify(config)
+                except:
+                    return jsonify(DEFAULT_STARTUP)
+                    
+            elif request.method == 'POST':
+                data = request.json
+                if not data:
+                    return jsonify({"status": "ERROR", "message": "No config data provided"}), 400
                 
-                media_type = "video" if actual_ext == ".mp4" else "image"
-                r2_url = _upload_studio_image_to_r2(output_file, filename)
-                if not r2_url:
-                    # [🔱] R2 저장은 필수다. 저장 실패는 곧 생성 실패로 보고한다.
-                    # (로컬 디스크 폴백 URL은 클라이언트에서 접근 불가 → '거짓 성공' 방지)
-                    return jsonify({"error": "이미지는 연성됐으나 R2 영구 저장에 실패했습니다. R2_LIVE_* 자격증명을 확인하십시오."}), 502
-                return jsonify({
-                    "status": "success",
-                    "url": r2_url,
-                    "filename": filename,
-                    "media_type": media_type
-                })
-
-            except Exception as e:
-                return jsonify({"error": f"헤파이스토스 엔진 오류: {str(e)}"}), 500
-
-        # --- 기존 Gemini 엔진 처리 로직 ---
-        # nano-banana 모델 ID를 실제 API 모델로 매핑
-        nano_model_map = {
-            "nano-banana": "gemini-2.0-flash",
-            "nano-banana-2": "gemini-3.1-flash-image-preview",
-            "nano-banana-pro": "gemini-3-pro-image-preview",
-            "nanobanana": "gemini-2.0-flash",
-        }
-        
-        # Determine actual API model for quota
-        api_model = model_id
-        if model_id in nano_model_map:
-            api_model = nano_model_map[model_id]
-            
-        # Check Quota
-        q_data = _load_image_quota()
-        current_usage = q_data.get('usage', {}).get(api_model, 0)
-        limit = STUDIO_IMAGE_LIMITS.get(api_model, 0)
-        
-        if limit > 0 and current_usage >= limit:
-            return jsonify({"error": f"이 모델의 일일 생성 한도({limit}회)를 초과했습니다. 내일 다시 시도해 주세요."}), 429
-        
-        try:
-            # Google GenAI 모델 (Imagen 또는 Gemini Image)
-            if model_id in nano_model_map:
-                res = cloud_tool.generate_image_nano_banana(prompt, model_id=api_model, output_file=output_file)
-            elif model_id.startswith("imagen-"):
-                res = cloud_tool.generate_image_google(prompt, model_id=model_id, aspect_ratio=aspect_ratio, output_file=output_file)
-            else:
-                res = cloud_tool.generate_image_nano_banana(prompt, output_file=output_file)
+                # Load existing to merge/validate if needed, or total override
+                # Selective merge to protect core structure if partial data sent
+                current = DEFAULT_STARTUP.copy()
+                if os.path.exists(config_path):
+                    try:
+                        with open(config_path, 'r', encoding='utf-8') as f:
+                            current = json.load(f)
+                    except: pass
                 
-            if res.get("success"):
-                _increment_image_quota(api_model)
-                r2_url = _upload_studio_image_to_r2(output_file, filename)
-                if not r2_url:
-                    # [🔱] R2 저장은 필수다. 저장 실패는 곧 생성 실패로 보고한다.
-                    return jsonify({"error": "이미지는 생성됐으나 R2 영구 저장에 실패했습니다. R2_LIVE_* 자격증명을 확인하십시오."}), 502
-                return jsonify({
-                    "status": "success",
-                    "url": r2_url,
-                    "filename": filename
-                })
-            else:
-                return jsonify({"error": res.get("error", "이미지 생성에 실패했습니다.")}), 500
-        except Exception as e:
-            logging.error(f"[Studio] Image generation failed: {e}")
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/studio/upload-image', methods=['POST', 'OPTIONS'])
-    def api_studio_upload_image():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        if 'file' not in request.files:
-            return jsonify({'status': 'ERROR', 'message': '파일이 선택되지 않았습니다.'}), 400
-            
-        file = request.files['file']
-        if file.filename == '':
-            return jsonify({'status': 'ERROR', 'message': '파일이 비어 있습니다.'}), 400
-            
-        ext = os.path.splitext(file.filename)[1].lower()
-        if ext not in ['.png', '.jpg', '.jpeg', '.webp', '.gif']:
-            return jsonify({'status': 'ERROR', 'message': '지원하지 않는 이미지 형식입니다.'}), 400
-            
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_%f')[:19]
-        s_filename = f"upload_{timestamp}{ext}"
-        
-        gen_dir = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "generated_images")
-        os.makedirs(gen_dir, exist_ok=True)
-        
-        filepath = os.path.join(gen_dir, s_filename)
-        file.save(filepath)
-        
-        return jsonify({
-            'status': 'SUCCESS',
-            'filename': s_filename,
-            'url': f'/api/studio/images/{s_filename}'
-        })
-
-    @app.route('/api/studio/images/<filename>', methods=['GET'])
-    def studio_serve_image(filename):
-        """생성된 이미지 서빙."""
-        gen_dir = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "generated_images")
-        return send_from_directory(gen_dir, filename)
-
-    def _studio_dialogue_root():
-        return os.path.join(project_root, "docker_data", "shared_workspace", "Dialogue")
-
-    def _studio_dir():
-        return os.path.join(_studio_dialogue_root(), "Studio")
-
-    def _studio_portraits_dir():
-        return os.path.join(_studio_dialogue_root(), "StudioPortraits")
-
-    def _hephaestus_output_candidates():
-        candidates = [
-            os.path.join(project_root, "docker_data", "wan2gp_workspace", "outputs"),
-            os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "generated_images"), # Gemini Studio Output
-            os.path.join(project_root, "docker_data", "wan2gp_workspace", "outputs2"),
-            os.path.join(project_root, "docker_data", "wan2gp_workspace", "gradio_outputs"),
-            os.path.join(project_root, "wan2gp", "outputs"),
-            os.path.join(project_root, "wan2gp", "outputs2"),
-            os.path.join(project_root, "wan2gp", "gradio_outputs"),
-            os.path.join(project_root, "..", "docker_data", "wan2gp_workspace", "outputs"),
-            os.path.join(project_root, "..", "docker_data", "shared_workspace", "JarvisRun", "generated_images"),
-            os.path.join(project_root, "..", "docker_data", "wan2gp_workspace", "outputs2"),
-            os.path.join(project_root, "..", "docker_data", "wan2gp_workspace", "gradio_outputs"),
-            os.path.join(project_root, "..", "wan2gp", "outputs"),
-            os.path.join(project_root, "..", "wan2gp", "outputs2"),
-            os.path.join(project_root, "..", "wan2gp", "gradio_outputs"),
-        ]
-        unique_paths = []
-        seen = set()
-        for path in candidates:
-            normalized = os.path.normcase(os.path.abspath(path))
-            if normalized in seen:
-                continue
-            seen.add(normalized)
-            unique_paths.append(os.path.abspath(path))
-        return unique_paths
-
-    def _sanitize_studio_slug(value):
-        text = re.sub(r"[^A-Za-z0-9가-힣_-]+", "_", str(value or "")).strip("_")
-        return text[:80] or "portrait"
-
-    def _hephaestus_online():
-        # Hephaestus(WanGP) 엔진 가용성 체크 - 5초 안에 응답 없으면 짧게 재확인
-        try:
-            # /config 또는 루트(/)로 체크. /config를 5초 타임아웃으로 체크
-            response = requests.get("http://127.0.0.1:8001/config", timeout=5)
-            return response.status_code == 200
-        except Exception:
-            # 보조로 루트(/) 체크 시도
-            try:
-                response = requests.get("http://127.0.0.1:8001/", timeout=2)
-                return response.status_code == 200
-            except:
-                return False
-
-    def _build_studio_portrait_prompt(topic, member):
-        name = member.get("name") or "배우"
-        role = member.get("role") or "핵심 조연"
-        gender = member.get("gender") or "female"
-        prompt_gender = "male" if str(gender).lower() == "male" else "female"
-        
-        # Add stylistic randomness
-        styles = [
-            "cinematic character portrait", "hyper-realistic close-up", "epic fantasy portrait",
-            "cyberpunk character shot", "heroic character profile", "ethereal digital art"
-        ]
-        atmospheres = [
-            "dramatic rim light", "soft dream-like lighting", "neon-soaked ambience",
-            "golden hour glow", "shadowy mystery", "volumetric light beams"
-        ]
-        backgrounds = [
-            "clean background", "blurred bokeh background", "imperial palace hall",
-            "sci-fi command deck", "misty ancient forest", "abstract light streaks"
-        ]
-        
-        style = random.choice(styles)
-        atmos = random.choice(atmospheres)
-        bg = random.choice(backgrounds)
-        
-        return (
-            f"{style}, {prompt_gender}, {name}, {role}, "
-            f"imperial fantasy sci-fi aesthetic, {atmos}, highly detailed face, "
-            f"luxury costume design, {bg}, upper body portrait, solo subject, "
-            f"story topic: {topic or 'imperial studio'}, masterpiece, best quality"
-        )
-
-    def _latest_hephaestus_image(exclude_path=None):
-        candidates = []
-        for outputs_dir in _hephaestus_output_candidates():
-            if not os.path.isdir(outputs_dir):
-                continue
-            for root_dir, _, filenames in os.walk(outputs_dir):
-                for filename in filenames:
-                    if not filename.lower().endswith((".png", ".jpg", ".jpeg", ".webp")):
-                        continue
-                    file_path = os.path.join(root_dir, filename)
-                    if not os.path.isfile(file_path):
-                        continue
-                    if exclude_path and os.path.normcase(os.path.abspath(file_path)) == os.path.normcase(os.path.abspath(exclude_path)):
-                        continue
-                    candidates.append(file_path)
-
-        if not candidates:
-            return None
-
-        candidates.sort(key=os.path.getmtime, reverse=True)
-        return candidates[0]
-
-    @app.route('/api/shadow/audio/studio/portrait/prompt', methods=['POST'])
-    def studio_portrait_prompt():
-        data = request.json or {}
-        topic = data.get("topic", "")
-        member = data.get("member") or {}
-        member_key = member.get("relayId") or member.get("name") or "portrait"
-        filename_prefix = _sanitize_studio_slug(f"studio_{member_key}_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
-        latest_path = _latest_hephaestus_image()
-
-        return jsonify({
-            "status": "success",
-            "prompt": _build_studio_portrait_prompt(topic, member),
-            "filename_prefix": filename_prefix,
-            "hephaestus_online": _hephaestus_online(),
-            "latest_output": os.path.basename(latest_path) if latest_path else None,
-            "has_latest_output": latest_path is not None,
-            "hephaestus_url": "http://127.0.0.1:8001",
-            "searched_dirs": [path.replace("\\", "/") for path in _hephaestus_output_candidates()],
-        })
-
-    @app.route('/api/shadow/audio/studio/portrait/attach-latest', methods=['POST'])
-    def studio_portrait_attach_latest():
-        data = request.json or {}
-        member = data.get("member") or {}
-        session_id = data.get("session_id") or "adhoc"
-        exclude_path = data.get("exclude_path")
-        portrait_file = data.get("portrait_file")  # 명시적인 파일명 지정
-        
-        latest_path = None
-        if portrait_file:
-            # generated_images 폴더에서 해당 파일 탐색
-            candidate_path = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "generated_images", portrait_file)
-            if os.path.exists(candidate_path):
-                latest_path = candidate_path
-        
-        if not latest_path:
-            latest_path = _latest_hephaestus_image(exclude_path=exclude_path)
-        if latest_path is None:
-            return jsonify({
-                "error": "Hephaestus 출력 이미지가 없습니다. 먼저 Hephaestus에서 이미지를 생성한 뒤 다시 연결하세요.",
-                "hephaestus_url": "http://127.0.0.1:8001",
-                "searched_dirs": [path.replace("\\", "/") for path in _hephaestus_output_candidates()],
-            }), 404
-
-        try:
-            portraits_dir = _studio_portraits_dir()
-            os.makedirs(portraits_dir, exist_ok=True)
-            member_key = member.get("relayId") or member.get("name") or "portrait"
-            ext = os.path.splitext(latest_path)[1].lower() or ".png"
-            filename = f"{_sanitize_studio_slug(session_id)}__{_sanitize_studio_slug(member_key)}__{datetime.now().strftime('%Y%m%d_%H%M%S')}{ext}"
-            copied_path = os.path.join(portraits_dir, filename)
-            with open(latest_path, "rb") as src, open(copied_path, "wb") as dst:
-                dst.write(src.read())
-
-            return jsonify({
-                "status": "success",
-                "portrait_file": filename,
-                "source_file": os.path.basename(latest_path),
-                "portrait_url": f"/api/shadow/audio/studio/portrait/file/{filename}",
-                "source_path": latest_path.replace("\\", "/"),
-            })
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
-
-    @app.route('/api/shadow/audio/studio/portrait/file/<path:filename>', methods=['GET'])
-    def studio_portrait_file(filename):
-        portraits_dir = _studio_portraits_dir()
-        os.makedirs(portraits_dir, exist_ok=True)
-        return send_from_directory(portraits_dir, filename)
-
-    @app.route('/api/shadow/audio/studio/rename', methods=['POST'])
-    def studio_rename():
-        """Rename an existing studio session."""
-        data = request.json or {}
-        session_id = data.get("session_id")
-        new_title = data.get("new_title")
-        
-        if not session_id or not new_title:
-            return jsonify({"error": "session_id and new_title are required"}), 400
-            
-        try:
-            studio_dir = _studio_dir()
-            json_path = os.path.join(studio_dir, f"{session_id}.json")
-            mp3_path = os.path.join(studio_dir, f"{session_id}.mp3")
-            
-            if not os.path.exists(json_path):
-                return jsonify({"error": "Session not found"}), 404
+                # Merge logic
+                for key in data:
+                    if key in current and isinstance(data[key], dict) and isinstance(current[key], dict):
+                        current[key].update(data[key])
+                    else:
+                        current[key] = data[key]
                 
-            # 1. Update JSON Metadata
-            with open(json_path, 'r', encoding='utf-8') as f:
-                meta = json.load(f)
-            
-            meta["title"] = new_title
-            
-            # 2. Generate New Session ID (Keep timestamp if possible)
-            # Example session_id: Studio_20260316_085603_Title
-            parts = session_id.split('_')
-            if len(parts) >= 3 and parts[0] == "Studio":
-                timestamp = f"{parts[1]}_{parts[2]}"
-            else:
-                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            
-            safe_title = "".join([c for c in new_title if c.isalnum() or c in (' ', '_')]).rstrip()[:30]
-            new_session_id = f"Studio_{timestamp}_{safe_title}"
-            
-            # 3. Rename Files
-            new_json_path = os.path.join(studio_dir, f"{new_session_id}.json")
-            new_mp3_path = os.path.join(studio_dir, f"{new_session_id}.mp3")
-            
-            # Save updated JSON to new path
-            with open(new_json_path, 'w', encoding='utf-8') as f:
-                json.dump(meta, f, ensure_ascii=False, indent=2)
-            
-            # Rename MP3 if exists
-            if os.path.exists(mp3_path):
-                # Ensure we don't overwrite if destination exists and is different
-                if mp3_path != new_mp3_path:
-                    if os.path.exists(new_mp3_path):
-                        os.remove(new_mp3_path)
-                    os.rename(mp3_path, new_mp3_path)
-            
-            # Delete old JSON if name changed
-            if json_path != new_json_path:
-                os.remove(json_path)
+                # [Imperial Standard] Ensure atomic write and UTF-8 encoding
+                os.makedirs(os.path.dirname(config_path), exist_ok=True)
+                with open(config_path, 'w', encoding='utf-8') as f:
+                    json.dump(current, f, ensure_ascii=False, indent=2)
+                
+                print(f"[Imperial Config] Startup configuration unified & updated via API.")
+                return jsonify({"status": "SUCCESS", "message": "기동 설정이 갱신되었습니다.", "config": current})
                 
-            return jsonify({"status": "success", "new_session_id": new_session_id})
         except Exception as e:
-            return jsonify({"error": str(e)}), 500
+            import traceback
+            traceback.print_exc()
+            return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-    @app.route('/api/shadow/audio/studio/list', methods=['GET'])
-    def studio_list():
-        """List saved studio sessions."""
+
+
+    # --- Imperial Knowledge Endpoints ---
+    @app.route('/api/knowledge/imperial_wisdom', methods=['GET'])
+    @app.route('/api/knowledge/imperial_wisdom.md', methods=['GET'])
+    def api_imperial_wisdom():
         try:
-            studio_dir = _studio_dir()
-            if not os.path.exists(studio_dir):
-                return jsonify([])
-            
-            files = [f for f in os.listdir(studio_dir) if f.endswith(".json")]
-            sessions = []
-            for f in files:
-                try:
-                    with open(os.path.join(studio_dir, f), "r", encoding="utf-8") as jf:
-                        sessions.append({"id": f.replace(".json", ""), "data": json.load(jf)})
-                except: continue
+            # Log visitor info for debugging help
+            ua = request.headers.get('User-Agent', 'Unknown')
+            ip = request.remote_addr
+            print(f"[Imperial Knowledge] Access attempt - Path: {request.path}, IP: {ip}, UA: {ua}")
             
-            # Sort by timestamp desc
-            sessions.sort(key=lambda x: x["data"].get("timestamp", ""), reverse=True)
-            return jsonify(sessions)
+            wisdom_path = os.path.join(project_root, "imperial_wisdom.md")
+            if os.path.exists(wisdom_path):
+                with open(wisdom_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                return Response(
+                    content, 
+                    mimetype='text/markdown', 
+                    headers={
+                        'Access-Control-Allow-Origin': '*',
+                        'Access-Control-Allow-Methods': 'GET, OPTIONS',
+                        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                        'Cache-Control': 'no-cache, no-store, must-revalidate',
+                        'Pragma': 'no-cache',
+                        'Expires': '0'
+                    }
+                )
+            return jsonify({"error": "File not found"}), 404
         except Exception as e:
             return jsonify({"error": str(e)}), 500
 
-    @app.route('/api/shadow/audio/studio/load/<session_id>', methods=['GET'])
-    def studio_load(session_id):
-        """Load a specific studio session."""
+    @app.route('/api/knowledge/mission_control', methods=['GET'])
+    @app.route('/api/knowledge/mission_control.md', methods=['GET'])
+    def api_mission_control():
         try:
-            studio_dir = _studio_dir()
-            file_path = os.path.join(studio_dir, f"{session_id}.json")
-            if not os.path.exists(file_path):
-                return jsonify({"error": "Session not found"}), 404
-            
-            with open(file_path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-            
-            # Add audio existence check
-            audio_path = os.path.join(studio_dir, f"{session_id}.mp3")
-            data["has_audio"] = os.path.exists(audio_path)
-            data.setdefault("casting_mode", "auto")
-            data.setdefault("selected_guardians", [])
-            data.setdefault("portrait_overrides", {})
+            ua = request.headers.get('User-Agent', 'Unknown')
+            ip = request.remote_addr
+            print(f"[Imperial Knowledge] Access attempt - Path: {request.path}, IP: {ip}, UA: {ua}")
             
-            return jsonify(data)
+            mission_path = os.path.join(project_root, "mission_control.md")
+            if os.path.exists(mission_path):
+                with open(mission_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                return Response(
+                    content, 
+                    mimetype='text/markdown', 
+                    headers={
+                        'Access-Control-Allow-Origin': '*',
+                        'Access-Control-Allow-Methods': 'GET, OPTIONS',
+                        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                        'Cache-Control': 'no-cache, no-store, must-revalidate',
+                        'Pragma': 'no-cache',
+                        'Expires': '0'
+                    }
+                )
+            return jsonify({"error": "File not found"}), 404
         except Exception as e:
             return jsonify({"error": str(e)}), 500
 
-    @app.route('/api/shadow/audio/studio/delete/<session_id>', methods=['DELETE'])
-    def studio_delete(session_id):
-        """Delete a studio session."""
+    @app.route('/api/system/rclone-setup', methods=['POST'])
+    def api_system_rclone_setup():
+        """Triggers the Rclone Google Drive setup script."""
         try:
-            studio_dir = _studio_dir()
-            json_path = os.path.join(studio_dir, f"{session_id}.json")
-            audio_path = os.path.join(studio_dir, f"{session_id}.mp3")
-            
-            deleted_files = []
-            if os.path.exists(json_path):
-                os.remove(json_path)
-                deleted_files.append("json")
-            if os.path.exists(audio_path):
-                os.remove(audio_path)
-                deleted_files.append("audio")
+            # Trigger the setup script in the background to avoid blocking the API
+            script_path = os.path.join(project_root, "shadow_brain_core", "rclone_setup.py")
+            if not os.path.exists(script_path):
+                return jsonify({"status": "ERROR", "message": f"Setup script not found: {script_path}"}), 404
             
-            if not deleted_files:
-                return jsonify({"error": "Session not found"}), 404
-                
-            return jsonify({"status": "success", "deleted": deleted_files})
+            # Start the setup script - note: this script is interactive, 
+            # so the user will need to interact with the backend console.
+            subprocess.Popen([sys.executable, script_path], creationflags=subprocess.CREATE_NEW_CONSOLE)
+            return jsonify({"status": "SUCCESS", "message": "Rclone setup started in new console."})
         except Exception as e:
-            return jsonify({"error": str(e)}), 500
+            return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-    @app.route('/api/shadow/tts/voices')
-    def get_unified_voices():
-        """제국 통합 음성 사령부(Orpheus): 모든 프로바이더의 음성 목록과 쿼터 정보를 반환합니다."""
-        all_voices = []
-        target_provider = request.args.get('provider', '').lower()
-        # [🔱 Imperial] Handle 'orpheus' as an alias for 'qwen'
-        if target_provider == 'orpheus':
-            target_provider = 'qwen'
+    # --- Sovereign Autonomy & Sandbox Endpoints ---
+    @app.route('/api/sovereign/task/start', methods=['POST'])
+    def api_sovereign_task_start():
+        """Starts a new autonomous iterative task."""
+        data = request.json
+        goal = data.get("goal")
+        if not goal:
+            return jsonify({"error": "Goal is required"}), 400
         
-        # 1. Google Gemini (Native Audio)
-        # return gemini if explicitly requested via provider=gemini OR if include_gemini=true
-        include_gemini = request.args.get("include_gemini", "false").lower() == "true"
-        if target_provider == 'gemini' or (not target_provider and include_gemini):
-            try:
-                gemini_voices = gemini_audio.get_voices()
-                for v in gemini_voices:
-                    v['provider'] = 'gemini'
-                    v['quota'] = '제한 (100 RPD)' if v['id'] != 'native_live' else '무제한 (Native Live)'
-                    all_voices.append(v)
-            except Exception as e:
-                print(f"[Orpheus] Gemini voices failed: {e}")
+        context = data.get("context")
+        use_sandbox = data.get("use_sandbox", True)
+        
+        auth_token = request.headers.get("X-Imperial-Token") or request.headers.get("Authorization", "").replace("Bearer ", "")
+        task_id = task_manager.start_task(goal, context=context, use_sandbox=use_sandbox, auth_token=auth_token)
+        return jsonify({"task_id": task_id, "status": "started"})
 
-        # 2. Alibaba Qwen3 (Windows Native / Orpheus)
-        if target_provider == 'qwen' or not target_provider:
-            # [🔱 Imperial Fleet Routing] Ensure unified routing for voice discovery
-            orpheus_url = cluster.get_orpheus_url() if cluster else os.environ.get("ORPHEUS_URL", "http://127.0.0.1:18800").rstrip('/')
-            print(f"[Orpheus] Voice discovery routing: {orpheus_url}", flush=True)
-            try:
-                res = requests.get(f"{orpheus_url}/voices", timeout=5)
-                if res.status_code == 200:
-                    qwen_voices = res.json()
-                    for v in qwen_voices:
-                        v['provider'] = 'qwen'
-                        v['quota'] = '무제한 (Windows Native)'
-                        all_voices.append(v)
-                else:
-                    raise Exception(f"Orpheus status {res.status_code}")
-            except Exception as e:
-                # [폴백 제거] Orpheus(Qwen) 보이스 서버가 죽었을 때 가짜 프리셋으로 덮지 않고 실패를 그대로 노출한다.
-                print(f"[Orpheus] Qwen voices fetch failed (no fallback): {e}", flush=True)
+    @app.route('/api/sovereign/task/status/<task_id>', methods=['GET'])
+    def api_sovereign_task_status(task_id):
+        """Returns the status and logs of an active sovereign task."""
+        status = task_manager.get_task_status(task_id)
+        if not status:
+            return jsonify({"error": "Task not found"}), 404
+        return jsonify(status)
 
-        # 3. OpenBMB VoxCPM2 (Voice Cloning Engine, Port 8001)
-        if target_provider == 'voxcpm' or not target_provider:
-            voxcpm_url = os.environ.get("VOXCPM_URL", "http://127.0.0.1:8001").rstrip('/')
-            try:
-                res = requests.get(f"{voxcpm_url}/voices", timeout=3)
-                if res.status_code == 200:
-                    voxcpm_voices = res.json()
-                    for v in voxcpm_voices:
-                        v['provider'] = 'voxcpm'
-                        v['quota'] = '음성 클로닝 (Windows Native)'
-                        all_voices.append(v)
-                else:
-                    raise Exception(f"VoxCPM status {res.status_code}")
-            except Exception as e:
-                # [폴백 제거] VoxCPM 서버가 죽었을 때 가짜 프리셋으로 덮지 않고 실패를 그대로 노출한다.
-                print(f"[TTS_VOICES] VoxCPM voices fetch failed (no fallback): {e}", flush=True)
+    @app.route('/api/sovereign/sandbox/cleanup', methods=['POST'])
+    def api_sovereign_sandbox_cleanup():
+        """Cleans up a specific sandbox session."""
+        task_id = request.json.get("task_id")
+        if not task_id:
+            return jsonify({"error": "Task ID is required"}), 400
+        success = phantom_sandbox.sandbox_manager.cleanup(task_id)
+        return jsonify({"success": success})
 
-        # [🔱 Imperial] De-duplicate voice IDs (Prioritize VoxCPM > Qwen > Gemini)
-        unique_voices_map = {v.get('id'): v for v in all_voices if v.get('id')}
+    @app.route('/api/sovereign/browser/execute', methods=['POST'])
+    def api_sovereign_browser_execute():
+        """
+        Executes a high-level browser mission autonomously.
+        Required: {"goal": "Mission description"}
+        Optional: {"headless": true/false}
+        """
+        data = request.json
+        goal = data.get("goal")
+        if not goal:
+            return jsonify({"error": "Goal is required"}), 400
         
-        # Preserve relative order while keeping only unique IDs (latest provider wins)
-        # However, for simplicity and ensuring VoxCPM wins:
-        final_voices = list(unique_voices_map.values())
+        headless = data.get("headless", True)
+        
+        # Initialize Agent
+        agent = SovereignMissionAgent()
         
-        return jsonify(final_voices)
+        # Execute (Runs in blocking mode for now, but could be threaded)
+        # For simplicity and 'Accuracy' (user's request), we run and report.
+        try:
+            result = agent.execute_mission(goal, headless=headless)
+            return jsonify(result)
+        except Exception as e:
+            return jsonify({"status": "error", "error": str(e)}), 500
 
-    @app.route('/api/shadow/audio/tts', methods=['POST'])
-    def audio_tts():
-        """
-        [🔱 Imperial Gateway] Synchronous TTS Generation.
-        Routes to either Gemini Native or Orpheus(Qwen) based on voice selection.
-        """
-        data = request.json or {}
-        text = data.get("text", "").strip()
-        voice = data.get("voice", "kore") # Default gemini voice
-        model = data.get("model", "")
-        format = data.get("format", "mp3")
-        speed = data.get("speed", "1.0")
-        pitch = data.get("pitch", "1.0")
+    # --- Phase 32: Imperial Data Isolation (JarvisRun Folder) ---
 
-        if not text:
-            return jsonify({"error": "텍스트가 비어있습니다."}), 400
 
-        print(f"[TTS_GATEWAY] Text: '{text[:50]}...', Voice: '{voice}', Provider Checking...", flush=True)
+    # --- Phase 32: Imperial Data Isolation (JarvisRun Folder) ---
 
-        # 1. Gemini Detection (Based on GEMINI_VOICES in engines/gemini_audio.py)
-        from engines.gemini_audio import GEMINI_VOICES
-        is_gemini = voice.lower() in GEMINI_VOICES or "gemini" in str(model).lower() or "native" in str(voice).lower()
-        is_voxcpm = "voxcpm" in str(model).lower() or str(data.get("provider", "")).lower() == "voxcpm"
+    jarvis_run_dir = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun")
 
-        if is_gemini:
-            print(f"[TTS_GATEWAY] Routing to Gemini Native Engine...", flush=True)
-            if 'gemini_audio' not in globals() or not gemini_audio or not gemini_audio.available:
-                return jsonify({"error": "Gemini Audio Engine is not available"}), 503
-            
-            try:
-                res = gemini_audio.tts(text, voice=voice, output_format=format)
-                if "error" in res:
-                    return jsonify({"error": res["error"]}), 500
-                
-                audio_bytes = res.get("audio_bytes")
-                if not audio_bytes:
-                    return jsonify({"error": "Generated audio is empty"}), 500
-                
-                import base64
-                b64_audio = base64.b64encode(audio_bytes).decode('utf-8')
-                res_mime = "audio/mpeg" if format == "mp3" else "audio/wav"
-                if b64_audio.startswith('UklGR'): # "RIFF" in base64 (WAV header)
-                    res_mime = "audio/wav"
+    os.makedirs(jarvis_run_dir, exist_ok=True)
 
-                return jsonify({
-                    "status": "success",
-                    "audio_base64": b64_audio,
-                    "mime_type": res_mime
-                })
-            except Exception as e:
-                print(f"[TTS_GATEWAY] Gemini critical error: {e}", flush=True)
-                return jsonify({"error": str(e)}), 500
 
-    @app.route('/api/shadow/audio/live/tts', methods=['POST'])
-    def audio_live_tts():
-        """
-        [🔱 Imperial Shadow Live Gateway] 
-        Gemini 3.1 Flash Live 모델을 직접 호출하는 실시간 음성 엔드포인트입니다.
-        """
-        data = request.json or {}
-        text = data.get("text", "").strip()
-        voice = data.get("voice", "Kore")
-        model = data.get("model", "gemini-2.0-flash")
 
-        if not text:
-            return jsonify({"error": "텍스트가 비어있습니다."}), 400
+    # --- Phase 69: Persistence of Proactive Settings ---
+    # Moved to blueprints/report_routes.py
 
-        print(f"[SHADOW_LIVE] Text: '{text[:50]}...', Voice: '{voice}', Model: '{model}'", flush=True)
+    def migrate_legacy_data():
 
-        if 'gemini_audio' not in globals() or not gemini_audio or not gemini_audio.available:
-            return jsonify({"error": "Gemini Audio Engine is not available"}), 503
+        """Migrates files from shared_workspace root to JarvisRun subdirectory."""
 
-        try:
-            # 🔱 마왕님 명령에 따라 동적 모델 선택 가능하도록 수정
-            res = gemini_audio.shadow_live_tts(text, voice=voice, model=model)
-            if "error" in res:
-                return jsonify({"error": res["error"]}), 500
-            
-            import base64
-            b64_audio = base64.b64encode(res.get("audio_bytes")).decode('utf-8')
-            
-            return jsonify({
-                "status": "success",
-                "audio_base64": b64_audio,
-                "mime_type": res.get("mime_type", "audio/wav"),
-                "provider": "shadow_live",
-                "model_used": res.get("model_used"),
-                "text": res.get("text")
-            })
-        except Exception as e:
-            print(f"[SHADOW_LIVE] Critical error: {e}", flush=True)
-            return jsonify({"error": str(e)}), 500
+        root_dir = os.path.join(project_root, "docker_data", "shared_workspace")
 
-        # 2. VoxCPM2 Voice Cloning Logic (Pure — No Gemini/Qwen mixing)
-        if is_voxcpm:
-            print(f"[TTS_GATEWAY] Routing to VoxCPM2 Engine (Port 8001)...", flush=True)
-            voxcpm_url = os.environ.get("VOXCPM_URL", "http://127.0.0.1:8001").rstrip('/')
-            try:
-                payload = {"text": text, "voice": voice.lower()}
-                resp = requests.post(f"{voxcpm_url}/tts", json=payload, timeout=300)
-                if resp.status_code == 200:
-                    import base64
-                    b64_audio = base64.b64encode(resp.content).decode('utf-8')
-                    return jsonify({
-                        "status": "success",
-                        "audio_base64": b64_audio,
-                        "mime_type": "audio/wav"
-                    })
-                else:
-                    return jsonify({"error": f"VoxCPM gateway error: {resp.status_code}"}), 502
-            except Exception as e:
-                return jsonify({"error": f"VoxCPM unreachable: {str(e)}"}), 503
+        legacy_files = [
 
-        # 3. Orpheus (Qwen) Logic - Pure Orpheus logic (No Gemini mixing)
-        print(f"[TTS_GATEWAY] Routing to Orpheus (Qwen) Engine...", flush=True)
-        qwen_text = re.sub(r'\(.*?\)', '', text).strip()
-        if not qwen_text: qwen_text = text
-        
-        QWEN_VOICE_MAP = {
-            'sohee':      'sohee',
-            'ryan':       'ryan',
-            'aiden':      'aiden',
-            'vivian':     'vivian',
-            'serena':     'serena',
-            'uncle_fu':   'uncle_fu',
-            'dylan':      'dylan',
-            'eric':       'eric',
-            'ono_anna':   'ono_anna',
-            'default':    'sohee'
-        }
-        voice_norm = QWEN_VOICE_MAP.get(voice.lower(), 'sohee')
-        
-        try:
-            if cluster:
-                gateway_url = f"{cluster.get_orpheus_url().rstrip('/')}/tts"
-            else:
-                default_url = os.environ.get("ORPHEUS_URL", "http://127.0.0.1:18800").rstrip('/')
-                gateway_url = f"{default_url}/tts"
-
-            payload = {
-                "text": qwen_text,
-                "voice": voice_norm,
-                "speed": float(speed),
-                "pitch": float(pitch),
-                "model": "local_nvfp4" if "local" in str(model).lower() else model
-            }
-            resp = requests.post(gateway_url, json=payload, timeout=300)
-            if resp.status_code == 200:
-                import base64
-                b64_audio = base64.b64encode(resp.content).decode('utf-8')
-                res_mime = "audio/mpeg" if format == "mp3" else "audio/wav"
-                if b64_audio.startswith('UklGR'):
-                    res_mime = "audio/wav"
-                return jsonify({
-                    "status": "success",
-                    "audio_base64": b64_audio,
-                    "mime_type": res_mime
-                })
-            else:
-                return jsonify({"error": f"Orpheus gateway error: {resp.status_code}"}), 502
-        except Exception as e:
-            return jsonify({"error": str(e)}), 500
+            "JARVIS_SIGNAL.json", "JARVIS_TODO.json", "JARVIS_TODO_ARCHIVE.json",
 
+            "JARVIS_TERMINAL.log", "JARVIS_CHAT_HISTORY.json", "JARVIS_SHADOW_SETTINGS.json",
 
+            "JARVIS_VOICE_SIGNAL.json", "JARVIS_AUTOTEST.json", "SHADOW_BRAIN_MODELS.json",
 
-    @app.route('/api/voice', methods=['GET', 'POST'])
+            "REDTEAM_TARGETS.json", "REDTEAM_TACTICAL_REPORT.json", "SOUL_LINK_LOG.json",
 
-    def handle_voice_signal():
+            "JARVISRUN_STATUS.json"
 
-        """Proactive TTS signal channel for the AI agent."""
+        ]
 
-        voice_signal_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_VOICE_SIGNAL.json")
+        import shutil
 
-        from flask import request
+        for f in legacy_files:
 
-        
+            old_path = os.path.join(root_dir, f)
 
-        if request.method == 'POST':
+            if os.path.exists(old_path):
 
-            data = request.json
+                new_path = os.path.join(jarvis_run_dir, f)
 
-            text = data.get("text", "")
+                if not os.path.exists(new_path):
 
-            voice = data.get("voice", "ryan")
+                    try:
 
-            if not text:
+                        shutil.move(old_path, new_path)
 
-                return jsonify({"status": "ERROR", "message": "No text provided"}), 400
+                        print(f"[Imperial Migration] {f} -> JarvisRun/")
 
-            
+                    except Exception as e:
 
-            try:
+                        print(f"[Migration Error] {f}: {e}")
 
-                payload = {
+                else:
 
-                    "text": text,
+                    try:
 
-                    "voice": voice,
+                        os.remove(old_path) # Data already exists in new area
 
-                    "timestamp": time.time()
+                    except: pass
+
+        
+
+        # Also migrate PNG evidence files
+
+        for f in os.listdir(root_dir):
+
+            if f.endswith(".png") and os.path.isfile(os.path.join(root_dir, f)):
+
+                try:
+
+                    shutil.move(os.path.join(root_dir, f), os.path.join(jarvis_run_dir, f))
+
+                except: pass
+
+
+
+    migrate_legacy_data()
 
-                }
 
-                with open(voice_signal_file, 'w', encoding='utf-8') as f:
 
-                    json.dump(payload, f, ensure_ascii=False)
+    # --- Phase 33: Version Sync from VERSION file to JARVISRUN_STATUS.json ---
 
-                return jsonify({"status": "SUCCESS"})
+    def sync_version_to_status():
+        """Reads the root VERSION file and updates JARVISRUN_STATUS.json with the canonical version."""
+        version_file = os.path.join(project_root, "VERSION")
+        status_file = os.path.join(jarvis_run_dir, "JARVISRUN_STATUS.json")
+        try:
+            with open(version_file, 'r', encoding='utf-8-sig') as f:
+                version_str = f.read().strip()
+        except OSError as e:
+            print(f"[Imperial Version Sync] Warning: Could not read VERSION file ({version_file}): {e}")
+            return
+        if not os.path.exists(status_file):
+            print(f"[Imperial Version Sync] Warning: Status file not found ({status_file}), skipping version sync.")
+            return
+        try:
+            with open(status_file, 'r', encoding='utf-8') as f:
+                status_data = json.load(f)
+            status_data['version'] = version_str
+            with open(status_file, 'w', encoding='utf-8') as f:
+                json.dump(status_data, f, ensure_ascii=False, indent=2)
+            print(f"[Imperial Version Sync] JARVISRUN_STATUS.json version updated to: {version_str}")
+        except (OSError, json.JSONDecodeError) as e:
+            print(f"[Imperial Version Sync] Warning: Could not update status file ({status_file}): {e}")
 
-            except Exception as e:
+    sync_version_to_status()
 
-                return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-        
 
-        else: # GET
+    # --- Phase 40: Deployment State Tracking ---
 
-            if os.path.exists(voice_signal_file):
+    deployment_status = {}
 
-                try:
+    secrets_sync_status = {"status": "IDLE", "step": "N/A"}
 
-                    with open(voice_signal_file, 'r', encoding='utf-8') as f:
 
-                        data = json.load(f)
 
-                    os.remove(voice_signal_file)
+    @app.route('/api/deploy/status', methods=['GET'])
 
-                    return jsonify(data)
+    def get_deploy_status():
 
-                except Exception:
+        """Returns the current deployment status of all projects."""
 
-                    pass
+        return jsonify(deployment_status)
 
-            return jsonify({"text": None})
 
 
+    # === Firebase Build Quota Tracker ===
 
-    @app.route('/api/shadow/action/execute', methods=['POST'])
+    QUOTA_FILE = os.path.join(project_root, "docker_data", "shared_workspace", "firebase_build_quota.json")
 
-    def execute_action():
+    FIREBASE_FREE_BUILDS = 30  # ~120min / ~4min per build
 
-        """Executes a pre-approved skill action."""
 
-        data = request.json
 
-        action = data.get("action")
+    def _load_quota():
 
-        
+        """Load or reset monthly build quota."""
 
-        if not action:
+        import json
 
-            return jsonify({"status": "ERROR", "message": "No action provided"}), 400
+        from datetime import datetime
 
-            
+        current_month = datetime.now().strftime('%Y-%m')
 
         try:
 
-            skill_path = os.path.join(project_root, "scripts", "jarvisrun", "skills", "git_manager.py")
-
-            if action == "git_push":
+            with open(QUOTA_FILE, 'r', encoding='utf-8') as f:
 
-                # Dynamic import or direct call
+                data = json.load(f)
 
-                spec = importlib.util.spec_from_file_location("git_manager", skill_path)
+            if data.get('month') != current_month:
 
-                git_manager = importlib.util.module_from_spec(spec)
+                data = {'month': current_month, 'count': 0, 'manual_count': 0, 'limit': FIREBASE_FREE_BUILDS}
 
-                spec.loader.exec_module(git_manager)
+                _save_quota(data)
 
-                
+            if 'manual_count' not in data:
 
-                res = git_manager.git_push_auto(project_root, "feat: [Jarvis] Genesis Auto-Push")
+                data['manual_count'] = 0
 
-                if res["success"]:
+                _save_quota(data)
 
-                    return jsonify({"status": "SUCCESS", "message": "코드 푸시(Git Push) 작전 성공!", "output": res["stdout"]})
+            return data
 
-                else:
+        except (FileNotFoundError, json.JSONDecodeError):
 
-                    return jsonify({"status": "ERROR", "message": "코드 푸시(Git Push) 작전 실패", "details": res["stderr"]})
+            data = {'month': current_month, 'count': 0, 'manual_count': 0, 'limit': FIREBASE_FREE_BUILDS}
 
-            elif action == "reintegration":
+            _save_quota(data)
 
-                # Reuse the existing reintegrate API logic or call it
+            return data
 
-                return run_reintegration()
 
-            else:
 
-                return jsonify({"status": "ERROR", "message": f"알 수 없는 작업: {action}"}), 400
+    def _save_quota(data):
 
-        except Exception as e:
+        import json
 
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
+        os.makedirs(os.path.dirname(QUOTA_FILE), exist_ok=True)
 
+        with open(QUOTA_FILE, 'w', encoding='utf-8') as f:
 
+            json.dump(data, f, ensure_ascii=False, indent=2)
 
-    @app.route('/api/shadow/auth/github', methods=['GET'])
 
-    def github_auth_init():
 
-        """Initiates GitHub Device Flow authentication."""
+    def _increment_quota():
 
-        client_id = "Iv1.b507a08c87ecfe98" # Standard VSCode/Copilot Client ID
+        data = _load_quota()
 
-        try:
+        data['count'] = data.get('count', 0) + 1
 
-            res = requests.post("https://github.com/login/device/code", data={
+        _save_quota(data)
 
-                "client_id": client_id,
+        return data
 
-                "scope": "read:user"
 
-            }, headers={"Accept": "application/json"}, timeout=10)
 
-            res.raise_for_status()
+    @app.route('/api/deploy/quota', methods=['GET'])
 
-            data = res.json()
+    def get_deploy_quota():
 
-            
+        """Returns Firebase build quota usage for current month."""
 
-            # Store device_code for polling
+        data = _load_quota()
 
-            session_id = str(int(time.time() * 1000))
+        remaining = max(0, data['limit'] - data['count'])
 
-            GITHUB_AUTH_SESSIONS[session_id] = {
+        percent = round((data['count'] / data['limit']) * 100) if data['limit'] > 0 else 0
 
-                "device_code": data.get("device_code"),
+        level = 'safe' if percent < 70 else ('warning' if percent < 90 else 'danger')
 
-                "expires_at": time.time() + data.get("expires_in", 900)
+        
 
-            }
+        # Storage usage estimate removed in favor of direct GCP Console monitoring
+        storage_used = 0.0
+        storage_limit = 5.0 # Firebase Spark Plan limit
+        storage_percent = 0
+        storage_level = 'safe'
 
-            
+        
 
-            return jsonify({
+        return jsonify({
 
-                "status": "SUCCESS",
+            'month': data['month'],
 
-                "session_id": session_id,
+            'used': data['count'],
 
-                "user_code": data.get("user_code"),
+            'limit': data['limit'],
 
-                "verification_uri": data.get("verification_uri")
+            'remaining': remaining,
 
-            })
+            'percent': percent,
 
-        except Exception as e:
+            'level': level,
 
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
+            'storage': {
 
+                'used': storage_used,
 
+                'limit': storage_limit,
 
-    @app.route('/api/shadow/auth/github/poll', methods=['POST'])
+                'percent': storage_percent,
 
-    def github_auth_poll():
+                'level': storage_level,
 
-        """Polls for GitHub authorization and saves the token."""
+                'manual_count': data['manual_count']
 
-        from flask import request
+            }
 
-        data = request.json
+        })
 
-        session_id = data.get("session_id")
 
-        if not session_id or session_id not in GITHUB_AUTH_SESSIONS:
 
-            return jsonify({"status": "ERROR", "message": "Invalid session"}), 400
+    @app.route('/api/deploy/storage/purge', methods=['POST'])
 
-            
+    def purge_deploy_storage():
 
-        session = GITHUB_AUTH_SESSIONS[session_id]
+        """Resets the manual deployment counter after user cleans up Firebase Console."""
 
-        if time.time() > session["expires_at"]:
+        data = _load_quota()
 
-            return jsonify({"status": "EXPIRED", "message": "Auth session expired"}), 400
+        data['manual_count'] = 0
 
-            
+        _save_quota(data)
 
-        client_id = "Iv1.b507a08c87ecfe98"
+        return jsonify({"status": "SUCCESS", "message": "Manual deployment counter reset. Imperial Sanctuary purified."})
 
-        try:
 
-            res = requests.post("https://github.com/login/oauth/access_token", data={
 
-                "client_id": client_id,
+    @app.route('/api/deploy/quota/sync', methods=['POST'])
 
-                "device_code": session["device_code"],
+    def sync_deploy_quota():
 
-                "grant_type": "urn:ietf:params:oauth:grant-type:device_code"
+        """Manually override the current month's build quota."""
 
-            }, headers={"Accept": "application/json"}, timeout=10)
+        req = request.json
 
-            res.raise_for_status()
+        if 'used' not in req:
 
-            token_data = res.json()
+            return jsonify({"status": "ERROR", "message": "Missing 'used' parameter"}), 400
 
             
 
-            if "access_token" in token_data:
+        data = _load_quota()
+
+        data['count'] = int(req['used'])
+
+        _save_quota(data)
 
-                token = token_data["access_token"]
+        return jsonify({"status": "SUCCESS", "message": f"Quota synced to {data['count']}"})
 
-                # Save to .env
 
-                env_path = os.path.join(project_root, ".env")
 
-                env_content = ""
+    @app.route('/api/secrets/sync/status', methods=['GET'])
 
-                if os.path.exists(env_path):
+    def get_secrets_sync_status():
 
-                    with open(env_path, 'r', encoding='utf-8') as f:
+        return jsonify(secrets_sync_status)
 
-                        env_content = f.read()
 
-                
 
-                if "GITHUB_TOKEN=" in env_content:
+    @app.route('/api/deploy/db/status', methods=['GET'])
+    def get_db_schema_status():
+        """Returns the current Prisma migration status for the project."""
+        project = request.args.get("project", "ether_bahamut")
+        if project != "ether_bahamut":
+            return jsonify({"status": "UNSUPPORTED", "message": "이 프로젝트는 키 감시를 지원하지 않습니다."})
 
-                    # Update existing
+        def check_db():
+            try:
+                # 1. Get DB URL from Bitwarden
+                bw_session = os.environ.get("BW_SESSION")
+                if not bw_session:
+                    return {"status": "LOCKED", "message": "Bitwarden Vault가 잠겨 있습니다."}
 
-                    new_env = re.sub(r'GITHUB_TOKEN=.*', f'GITHUB_TOKEN={token}', env_content)
+                # Get the preview URL for status checks
+                cmd_get_secret = 'powershell -Command "bw get password \'Imperial: PREVIEW_DATABASE_URL\' --raw"'
+                res_secret = subprocess.run(cmd_get_secret, shell=True, capture_output=True, text=True, encoding='utf-8')
+                db_url = res_secret.stdout.strip().replace('"', '').replace("'", "")
+                
+                if not db_url or "Auto-migrated" in db_url:
+                    return {"status": "ERROR", "message": "DB URL을 찾을 수 없습니다."}
 
+                # 2. Run prisma migrate status
+                target_dir = os.path.join(project_root, "ether-bahamut")
+                env_copy = os.environ.copy()
+                env_copy["DATABASE_URL"] = db_url
+                
+                # Check for prisma existence
+                cmd_status = "npx.cmd prisma migrate status"
+                res_status = subprocess.run(cmd_status, shell=True, cwd=target_dir, env=env_copy, capture_output=True, text=True, encoding='utf-8')
+                
+                output = res_status.stdout + res_status.stderr
+                if "Database schema is up to date" in output:
+                    return {"status": "SYNCED", "message": "최신 상태 (동기화됨)"}
+                elif "migrations are not yet applied" in output:
+                    # Count pending migrations if possible
+                    return {"status": "PENDING", "message": "⚠️ 마이그레이션 필요"}
+                elif "error" in output.lower():
+                    return {"status": "ERROR", "message": "DB 연결 오류"}
                 else:
+                    return {"status": "UNKNOWN", "message": "상태 확인 불가"}
+                    
+            except Exception as e:
+                return {"status": "ERROR", "message": f"시스템 오류: {str(e)}"}
+
+        result = check_db()
+        return jsonify(result)
 
-                    # Add new
 
-                    new_env = env_content + f'\nGITHUB_TOKEN={token}\n'
 
-                
+    # [🔱 Imperial] Deployment logic has been migrated to blueprints/deployment_routes.py\n    @app.route('/redteam')
+
+    def redteam_console():
 
-                with open(env_path, 'w', encoding='utf-8') as f:
+        """Serves the Red Team tactical audit interface."""
 
-                    f.write(new_env)
+        return render_template('redteam.html')
 
-                
 
-                # Signal restart
 
-                signal_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_SIGNAL.json")
+    # [���� Imperial] Red Team audit logic has been migrated to blueprints/audit_routes.py
+    def serve_guardian_assets(guardian_id, filename):
+        """Serves assets from specific guardian workspaces (Soul Bridge)."""
+        from flask import send_from_directory
+        workspace_map = {
+            "hugin": os.path.join(project_root, "scripts", "hugin"),
+            "shadowbrain": os.path.join(os.path.dirname(project_root), "docker_data", "shared_workspace", "JarvisRun"),
+            "jarvis": os.path.join(os.path.dirname(project_root), "docker_data", "shared_workspace", "JarvisRun"),
+            "aris": os.path.join(project_root, "docker_data", "shared_workspace", "Aris")
+        }
+        base_path = workspace_map.get(guardian_id.lower())
+        
+        if not base_path:
+            base_path = os.path.join(project_root, "docker_data", "shared_workspace", guardian_id.capitalize())
+            
+        if os.path.exists(base_path):
+            return send_from_directory(base_path, filename)
+        return jsonify({"error": "Workspace not found"}), 404
 
-                with open(signal_file, 'w', encoding='utf-8') as f:
+    def _is_flutter_debug_server_running(port=38790):
+        """flutter run --debug 서버(38790)가 기동 중인지 빠르게 체크합니다."""
+        import socket as _socket
+        s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
+        s.settimeout(0.1)
+        try:
+            s.connect(('127.0.0.1', port))
+            s.close()
+            return True
+        except Exception:
+            return False
 
-                    json.dump({
+    @app.route('/')
 
-                        "signal": "RESTART",
+    def index():
 
-                        "content": "GitHub OAuth Success",
+        # flutter run --debug 서버(38790)가 살아 있으면 그쪽으로 리다이렉트 (최신 코드)
+        # 🔱 RunJarvis_Web.bat 개발 중일 때 18700과 38790이 자동 연동됨
+        from flask import redirect as _redirect
+        if _is_flutter_debug_server_running(38790):
+            return _redirect('http://localhost:38790/', code=302)
 
-                        "sender": "System",
+        # Serve the main index.html (Heimdall or Legacy)
 
-                        "timestamp": time.time()
+        target = 'index.html' if os.path.exists(os.path.join(app.static_folder, 'index.html')) else 'dashboard.html'
 
-                    }, f, ensure_ascii=False)
+        from flask import make_response, send_from_directory
 
-                
+        return send_from_directory(app.static_folder, target)
 
-                return jsonify({"status": "SUCCESS", "message": "인증 성공! 시스템을 재시작합니다."})
 
-            
 
-            error = token_data.get("error")
+    @app.route('/api/status')
 
-            if error == "authorization_pending":
+    def status():
 
-                return jsonify({"status": "PENDING"})
+        status_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVISRUN_STATUS.json")
 
-            elif error == "slow_down":
+        try:
 
-                return jsonify({"status": "SLOW_DOWN"})
+            if os.path.exists(status_file):
 
-            else:
+                with open(status_file, 'r', encoding='utf-8') as f:
 
-                return jsonify({"status": "ERROR", "message": token_data.get("error_description", error)})
+                    data = json.load(f)
 
                 
 
-        except Exception as e:
-
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
-
+                # --- Phase: Eternal Watch Status ---
 
+                data['external_health'] = data.get('external_services', {})
 
-    @app.route('/api/skills', methods=['GET'])
+                
 
-    def list_skills():
+                # --- Phase 5: Guardian Location Display ---
 
-        """Scans .agent/skills and .agent/workflows for the web dashboard."""
+                if cluster:
 
-        skills = []
+                    try:
 
-        
+                        data['allocations'] = cluster.get_config().get('allocations', {})
 
-        # 1. Scan Skills
+                    except Exception:
 
-        skills_dir = os.path.join(project_root, ".agent", "skills")
+                        data['allocations'] = {}
 
-        if os.path.exists(skills_dir):
 
-            for skill_name in os.listdir(skills_dir):
 
-                skill_path = os.path.join(skills_dir, skill_name, "SKILL.md")
+                # Staleness check: if heartbeat is older than 45 seconds,
 
-                if os.path.exists(skill_path):
+                # the engine is stopped/restarting - treat all guardians as offline
 
-                    data = parse_skill_md(skill_path)
+                ts = data.get('timestamp', 0)
 
-                    data['type'] = 'SKILL'
+                age = time.time() - ts
 
-                    skills.append(data)
+                if age > 45:
 
+                    stale_guardians = {k: False for k in data.get('guardians', {})}
 
+                    data['guardians'] = stale_guardians
 
-        # 2. Scan Workflows
+                    data['stale'] = True
 
-        workflows_dir = os.path.join(project_root, ".agent", "workflows")
+                    data['stale_age'] = int(age)
+                    
+                # [🔱] Guardian Ports Mapping for UI (Fallback for Shadow Brain)
+                # Map standard keys to ports
+                port_map = {
+                    "drako": "5432", "orpheus": "18800", "wan2gp": "8003",
+                    "heimdall": "18701", "aizen": "18789", "hugin": "18792", 
+                    "hermes": "18790", "shadow_brain": "18700", "shadow_rust_brain": "18710", 
+                    "hydra": "8002", "tiamat": "8080", "atlas": "18799", 
+                    "bastion": "18702", "gemini_voice": "18721", "pandora": "8001", 
+                    "bahamut": "3002", "ether": "3002", "iris": "4000", "ether_portal": "4000"
+                }
+                
+                # Create guardian_ports mapping matching the exact keys found in data['guardians']
+                # or based on known labels if the keys are complex labels
+                guardian_ports = {}
+                guardians = data.get('guardians', {})
+                for k in guardians.keys():
+                    port = ""
+                    k_lower = k.lower()
+                    for std_k, p in port_map.items():
+                        if std_k in k_lower:
+                            port = p
+                            break
+                    guardian_ports[k] = port
+                
+                data['guardian_ports'] = guardian_ports
 
-        if os.path.exists(workflows_dir):
+                return jsonify(data)
 
-            for wf_file in os.listdir(workflows_dir):
+        except Exception as e:
 
-                if wf_file.endswith(".md"):
+            return jsonify({"error": str(e)}), 500
 
-                    wf_path = os.path.join(workflows_dir, wf_file)
+        return jsonify({"status": "OFFLINE"})
 
-                    data = parse_skill_md(wf_path)
 
-                    data['type'] = 'WORKFLOW'
 
-                    if data.get('name') == 'Unnamed':
+    @app.route('/api/status/sync', methods=['GET', 'POST'])
 
-                        data['name'] = wf_file.replace(".md", "")
+    def handle_sync_status():
 
-                    skills.append(data)
+        global is_syncing
 
-                    
+        from flask import request
 
-        return jsonify(skills)
+        if request.method == 'POST':
 
+            data = request.json
 
+            is_syncing = data.get("is_syncing", False)
 
-    @app.route('/api/skills/info', methods=['GET'])
+            print(f"[.env Migration] Syncing state set to: {is_syncing}")
 
-    def get_skill_info():
+            return jsonify({"status": "SUCCESS", "is_syncing": is_syncing})
 
-        """Returns the full markdown content of a skill, skipping frontmatter."""
+        else:
 
-        skill_id = request.args.get('id')
+            return jsonify({"is_syncing": is_syncing})
 
-        if not skill_id:
 
-            return jsonify({"error": "No skill ID provided"}), 400
 
-            
+    @app.route('/api/config')
 
-        # We need to find the file. skill_id is the basename for workflows or dirname for skills.
+    def get_config():
 
-        # This is a bit brittle, let's search.
+        version_file = os.path.join(project_root, "VERSION")
+        try:
+            with open(version_file, 'r', encoding='utf-8-sig') as f:
+                version_str = f.read().strip()
+        except Exception:
+            version_str = "UNKNOWN"
 
-        search_dirs = [
+        return jsonify({
 
-            os.path.join(project_root, ".agent", "skills"),
+            "version": version_str,
 
-            os.path.join(project_root, ".agent", "workflows")
+            "dev_mode": "ACTIVE",
 
-        ]
+            "neural_link_stability": "99.9%",
 
-        
+            "last_sync": os.path.getmtime(__file__)
 
-        target_path = None
+        })
 
-        for d in search_dirs:
 
-            if not os.path.exists(d): continue
+    @app.route('/api/shadow/ask/answer', methods=['POST', 'OPTIONS'])
+    def shadow_ask_answer():
+        """🙋 [Ask User] 헤임달 선택지 버튼 탭 수신 — 대기 중인 추론 루프를 깨운다."""
+        if request.method == 'OPTIONS':
+            return '', 204
+        try:
+            data = request.json or {}
+            ask_id = str(data.get('ask_id') or '').strip()
+            # 🚫 취소 신호 (수호자 전환/창 닫기 등) — 대기 루프가 즉시 깨어나 보수적으로 마무리
+            answer = "__CANCELLED__" if data.get('cancel') else str(data.get('answer') or '').strip()
+            if not ask_id or not answer:
+                return jsonify({"status": "ERROR", "message": "ask_id와 answer는 필수입니다."}), 400
+            from brain.core import submit_ask_answer
+            if submit_ask_answer(ask_id, answer):
+                return jsonify({"status": "SUCCESS", "ask_id": ask_id})
+            # 만료/취소된 질문 — 헤임달은 이 응답을 받으면 일반 채팅 메시지로 폴백 전송
+            return jsonify({"status": "EXPIRED", "message": "해당 질문은 이미 만료되었거나 취소되었습니다."}), 410
+        except Exception as e:
+            return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-            for root, dirs, files in os.walk(d):
+    @app.route('/api/shadow/ask/begin', methods=['POST', 'OPTIONS'])
+    def shadow_ask_begin():
+        """🙋 [Ask Bridge] 외부 에이전트(헤르메스 MCP 등)가 선택지 질문을 등록한다."""
+        if request.method == 'OPTIONS':
+            return '', 204
+        try:
+            data = request.json or {}
+            if not str(data.get('question', '')).strip() or not data.get('options'):
+                return jsonify({"status": "ERROR", "message": "question과 options는 필수입니다."}), 400
+            from brain.core import begin_ask
+            return jsonify({"status": "SUCCESS", "ask": begin_ask(data)})
+        except Exception as e:
+            return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-                for f in files:
+    @app.route('/api/shadow/ask/wait', methods=['POST', 'OPTIONS'])
+    def shadow_ask_wait():
+        """🙋 [Ask Bridge] 답변까지 블로킹 대기(long-poll). ANSWERED/CANCELLED/TIMEOUT 반환."""
+        if request.method == 'OPTIONS':
+            return '', 204
+        try:
+            data = request.json or {}
+            ask_id = str(data.get('ask_id') or '').strip()
+            if not ask_id:
+                return jsonify({"status": "ERROR", "message": "ask_id는 필수입니다."}), 400
+            timeout = max(5, min(int(data.get('timeout_seconds', 120) or 120), 600))
+            from brain.core import wait_ask
+            answer = wait_ask(ask_id, timeout)
+            if answer is None:
+                return jsonify({"status": "TIMEOUT"})
+            if answer == "__CANCELLED__":
+                return jsonify({"status": "CANCELLED"})
+            return jsonify({"status": "ANSWERED", "answer": answer})
+        except Exception as e:
+            return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-                    if f == skill_id or os.path.basename(root) == skill_id:
+    @app.route('/api/shadow/ask/pending', methods=['GET', 'OPTIONS'])
+    def shadow_ask_pending():
+        """🙋 [Ask Bridge] 대기 중 질문 목록 — 헤임달이 폴링하여 카드를 out-of-band 표시."""
+        if request.method == 'OPTIONS':
+            return '', 204
+        try:
+            from brain.core import list_pending_asks
+            return jsonify({"status": "SUCCESS", "asks": list_pending_asks()})
+        except Exception as e:
+            return jsonify({"status": "ERROR", "message": str(e), "asks": []}), 200
 
-                        if f.endswith(".md"):
+    @app.route('/api/shadow/web_search', methods=['POST', 'OPTIONS'])
+    def shadow_web_search():
+        """🌐 [Web Search] 실시간 웹 검색 — 내부 google-surf MCP를 호출해 결과 텍스트를 반환.
 
-                            target_path = os.path.join(root, f)
+        imperial MCP의 web 번들(search_web)이 이 엔드포인트를 호출한다. 덕분에 외부
+        수호자(헤르메스 등)는 google-surf npm 서버를 따로 안 깔고 우리 MCP만으로 검색하며,
+        실제 검색(브라우저)은 쉐도우 브레인에서 중앙 실행된다.
+        """
+        if request.method == 'OPTIONS':
+            return '', 204
+        data = request.get_json(silent=True) or {}
+        query = (data.get('query') or data.get('q') or '').strip()
+        if not query:
+            return jsonify({"status": "ERROR", "message": "query가 필요합니다."}), 400
+        try:
+            limit = max(1, min(10, int(data.get('limit', 5))))
+        except (TypeError, ValueError):
+            limit = 5
+        try:
+            # 환경 무관 동작: google-surf(브라우저 MCP)가 연결돼 있으면 사용(로컬/주거용 IP에 적합),
+            # 미연결이면(클라우드 등) 네이버 headless Playwright(local_playwright_search)로 폴백한다.
+            # → 구글은 데이터센터 IP에서 캡차로 막히므로 클라우드에선 네이버 경로가 자동 사용됨.
+            from mcp_client import get_mcp_client
+            _mc = get_mcp_client() if get_mcp_client else None
+            _has_surf = bool(_mc and 'google-surf' in getattr(_mc, '_active_servers', []))
+            if _has_surf:
+                result = _mc.call_tool_sync('google-surf', 'search',
+                                            {"query": query[:400], "limit": limit}, timeout=150)
+            elif jarvis_brain is not None and getattr(jarvis_brain, 'browser', None) is not None:
+                # 네이버→다음→구글 headless 검색 (구글 캡차/디스플레이 무관, API 키 불필요)
+                result = jarvis_brain.browser.local_playwright_search(query[:400])
+            else:
+                return jsonify({"status": "ERROR",
+                                "message": "검색 엔진 미가용 (google-surf/Playwright 모두 불가)"}), 503
+            return jsonify({"status": "SUCCESS", "query": query, "result": result})
+        except Exception as e:
+            logger.error(f"[Web Search] 실패: {e}")
+            return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-                            break
+    @app.route('/api/mcp/directories', methods=['GET', 'POST', 'OPTIONS'])
+    def manage_mcp_directories():
+        if request.method == 'OPTIONS':
+            return '', 204
 
-                if target_path: break
+        # [🔱 Writable MCP Config] 쓰기 가능한 사용자 폴더(LOCALAPPDATA) 사본을 읽고 쓴다.
+        # (Program Files 사본은 권한 때문에 저장 불가)
+        try:
+            from mcp_client import resolve_mcp_config_path
+            mcp_config_path = resolve_mcp_config_path()
+        except Exception:
+            mcp_config_path = os.path.join(core_root, 'mcp_servers.json')
 
-            if target_path: break
+        if request.method == 'GET':
+            try:
+                if not os.path.exists(mcp_config_path):
+                    return jsonify({"status": "SUCCESS", "directories": []})
+                with open(mcp_config_path, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                
+                directories = []
+                for server in config.get('servers', []):
+                    if server.get('name') == 'filesystem':
+                        args = server.get('args', [])
+                        try:
+                            idx = args.index("@modelcontextprotocol/server-filesystem")
+                            directories = args[idx+1:]
+                        except ValueError:
+                            pass
+                return jsonify({"status": "SUCCESS", "directories": directories})
+            except Exception as e:
+                logger.error(f"[MCP API] Failed to read directories: {e}")
+                return jsonify({"status": "ERROR", "message": str(e)}), 500
+                
+        elif request.method == 'POST':
+            try:
+                data = request.json or {}
+                new_dirs = data.get('directories', [])
+                if not isinstance(new_dirs, list):
+                    return jsonify({"status": "ERROR", "message": "directories must be a list"}), 400
+                
+                # [🔱 Imperial Fix] mcp_servers.json 없으면 기본 구조로 자동 생성
+                if not os.path.exists(mcp_config_path):
+                    logger.info("[MCP API] mcp_servers.json not found. Creating default config...")
+                    default_config = {
+                        "servers": [
+                            {
+                                "name": "filesystem",
+                                "command": "npx",
+                                "args": ["-y", "@modelcontextprotocol/server-filesystem"]
+                            }
+                        ]
+                    }
+                    with open(mcp_config_path, 'w', encoding='utf-8') as f:
+                        json.dump(default_config, f, indent=2, ensure_ascii=False)
+                
+                with open(mcp_config_path, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                
+                # filesystem 서버 탐색 및 업데이트
+                updated = False
+                for server in config.get('servers', []):
+                    if server.get('name') == 'filesystem':
+                        base_args = ["-y", "@modelcontextprotocol/server-filesystem"]
+                        server['args'] = base_args + new_dirs
+                        updated = True
+                        break
+                
+                # filesystem 서버가 없으면 새로 추가
+                if not updated:
+                    if 'servers' not in config:
+                        config['servers'] = []
+                    config['servers'].append({
+                        "name": "filesystem",
+                        "command": "npx",
+                        "args": ["-y", "@modelcontextprotocol/server-filesystem"] + new_dirs
+                    })
+                    updated = True
+                        
+                with open(mcp_config_path, 'w', encoding='utf-8') as f:
+                    json.dump(config, f, indent=2, ensure_ascii=False)
+                return jsonify({"status": "SUCCESS", "message": "MCP directories updated. Restart required."})
+            except Exception as e:
+                logger.error(f"[MCP API] Failed to update directories: {e}")
+                return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-            
 
-        if not target_path or not os.path.exists(target_path):
+    @app.route('/api/logs')
 
-            return jsonify({"error": "Skill specification not found"}), 404
+    def get_logs():
 
-            
+        log_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_TERMINAL.log")
 
         try:
 
-            with open(target_path, 'r', encoding='utf-8') as f:
-
-                content = f.read()
-
-            # Remove frontmatter
-
-            body = re.sub(r'^---\s*\n.*?\n---\s*\n', '', content, flags=re.DOTALL)
-
-            return jsonify({"content": body.strip(), "name": skill_id})
+            if os.path.exists(log_file):
+                with open(log_file, 'r', encoding='utf-8', errors='replace') as f:
+                    lines = f.readlines()
+                    return jsonify({"logs": lines[-500:]}) # Standard Imperial Buffer Size
 
         except Exception as e:
 
             return jsonify({"error": str(e)}), 500
 
-
-
-    def parse_skill_md(file_path):
-        """Parses frontmatter from SKILL.md or workflow files (Backend version)."""
-        content = None
-        # Try multiple encodings for resilience
-        for enc in ['utf-8-sig', 'utf-8', 'cp949', 'euc-kr']:
-            try:
-                with open(file_path, 'r', encoding=enc) as f:
-                    content = f.read()
-                break
-            except UnicodeDecodeError:
-                continue
-        
-        # Last resort: read as utf-8 with replacement for invalid chars
-        if content is None:
-            try:
-                with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
-                    content = f.read()
-            except Exception:
-                return {"id": "error", "name": "Loading Error", "description": "Failed to read skill specification (Fatal Encoding Error)."}
-
-        try:
-            match = re.search(r'^\s*---\s*\n(.*?)\n---\s*', content, re.DOTALL)
-            if match:
-                frontmatter = match.group(1)
-                try:
-                    data = yaml.safe_load(frontmatter)
-                    return {
-                        "id": os.path.basename(os.path.dirname(file_path)) if "skills" in file_path else os.path.basename(file_path),
-                        "name": data.get("name", "Unnamed"),
-                        "description": data.get("description", "No description."),
-                        "category": data.get("category", "ETC").upper(),
-                        "command": data.get("command")
-                    }
-                except: pass
-            
-            return {"id": os.path.basename(file_path), "name": "Unnamed", "description": "Manual analysis required."}
-        except:
-            return {"id": "error", "name": "Loading Error", "description": "Failed to parse skill specification."}
+        return jsonify({"logs": ["Initializing tactical link..."]})
 
 
 
-    @app.route('/api/skills/execute', methods=['POST'])
+    # Imperial health/guardian action → blueprints/imperial_ops_routes.py
+    from blueprints.imperial_ops_routes import init_imperial_ops_routes
+    init_imperial_ops_routes(app, project_root)
 
-    def execute_skill_web():
+    # Goals/routines/archive/welcome → blueprints/goals_routines_routes.py
+    from blueprints.goals_routines_routes import init_goals_routines_routes
+    init_goals_routines_routes(
+        app, project_root,
+        get_jarvis_brain=lambda: getattr(app, "jarvis_brain", None) or jarvis_brain,
+        get_cluster=lambda: cluster,
+    )
 
-        """Triggers a skill execution via imperial signal."""
 
-        data = request.json
 
-        command = data.get("command")
 
-        name = data.get("name", "Unknown Skill")
+    # ============================================================
 
-        
+    # 🎭 Imperial Studio → blueprints/studio_routes.py
+    from blueprints.studio_routes import init_studio_routes
+    init_studio_routes(
+        app,
+        project_root,
+        get_jarvis_brain=lambda: getattr(app, "jarvis_brain", None) or jarvis_brain,
+        gemini_audio=gemini_audio,
+    )
+
+    # 🎙️ TTS gateway → blueprints/tts_routes.py
+    from blueprints.tts_routes import init_tts_routes
+    init_tts_routes(
+        app,
+        project_root,
+        gemini_audio=gemini_audio,
+        get_cluster=lambda: cluster,
+    )
 
-        if not command:
 
-            return jsonify({"status": "ERROR", "message": "No command defined for this protocol."}), 400
+    @app.route('/api/voice', methods=['GET', 'POST'])
 
-            
+    def handle_voice_signal():
 
-        signal_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_SIGNAL.json")
+        """Proactive TTS signal channel for the AI agent."""
 
-        try:
+        voice_signal_file = os.path.join(project_root, "docker_data", "shared_workspace", "JarvisRun", "JARVIS_VOICE_SIGNAL.json")
 
-            # Construct full path if relative
+        from flask import request
 
-            full_cmd = command
+        
 
-            if not os.path.isabs(command):
+        if request.method == 'POST':
 
-                full_cmd = os.path.normpath(os.path.join(project_root, command))
+            data = request.json
 
+            text = data.get("text", "")
 
+            voice = data.get("voice", "ryan")
 
-            payload = {
+            if not text:
 
-                "signal": "EXEC",
+                return jsonify({"status": "ERROR", "message": "No text provided"}), 400
 
-                "content": f'start "{name}" cmd /c "{full_cmd}"',
+            
 
-                "sender": "Imperial Web Command",
+            try:
 
-                "timestamp": time.time()
+                payload = {
 
-            }
+                    "text": text,
 
-            with open(signal_file, 'w', encoding='utf-8') as f:
+                    "voice": voice,
 
-                json.dump(payload, f, ensure_ascii=False)
+                    "timestamp": time.time()
 
-            
+                }
 
-            return jsonify({"status": "SUCCESS", "message": f"실행 명령 전송 완료: {name}"})
+                with open(voice_signal_file, 'w', encoding='utf-8') as f:
 
-        except Exception as e:
+                    json.dump(payload, f, ensure_ascii=False)
 
-            return jsonify({"status": "ERROR", "message": str(e)}), 500
+                return jsonify({"status": "SUCCESS"})
 
+            except Exception as e:
 
+                return jsonify({"status": "ERROR", "message": str(e)}), 500
 
-    @app.route('/api/shadow/audio/tts/dialogue', methods=['POST'])
-    def audio_tts_dialogue():
-        """🔱 [Imperial Core] Multi-speaker Dialogue TTS Gateway."""
-        data = request.json
-        script_text = data.get("text", "")
-        speakers = data.get("speakers", []) # List of {"name": "...", "voice": "..."}
-        engine = data.get("engine", "gemini").lower()
-        selected_model = data.get("model")
+        
 
-        if not script_text:
-            return jsonify({"status": "error", "message": "대본이 비어있습니다."}), 400
+        else: # GET
 
-        # 1. Parse Dialogue segments
-        segments = gemini_audio.parse_dialogue(script_text)
-        
-        # 2. Build voice map for Orpheus/VoxCPM
-        voice_map = {s.get("name"): s.get("voice") for s in speakers if s.get("name")}
+            if os.path.exists(voice_signal_file):
 
-        try:
-            audio_bytes = None
-            mime_type = "audio/wav"
-
-            if engine == "gemini":
-                # [🔱 Imperial] Gemini handles its own parallel dialogue generation
-                # Re-map speakers to configurations
-                speaker_configs = [{"name": s.get("name"), "voice": s.get("voice")} for s in speakers if s.get("name")]
-                res = gemini_audio.tts(script_text, speaker_configs=speaker_configs, model=selected_model)
-                audio_bytes = res.get("audio_bytes")
-                mime_type = res.get("mime_type", "audio/wav")
-
-            elif engine == "voxcpm":
-                # [🔱 Imperial] VoxCPM sequential generation with FFmpeg merging
-                voxcpm_url = os.environ.get("VOXCPM_URL", "http://127.0.0.1:8001").rstrip('/')
-                audio_chunks = []
-                for seg in segments:
-                    vx_voice = voice_map.get(seg["speaker"], seg["speaker"])
-                    try:
-                        vx_res = requests.post(f"{voxcpm_url}/tts", json={"text": seg["text"], "voice": vx_voice.lower()}, timeout=300)
-                        if vx_res.status_code == 200 and vx_res.content:
-                            audio_chunks.append(vx_res.content)
-                    except Exception as e:
-                        print(f"[VoxCPM] Segment generation failed: {e}")
-                
-                if audio_chunks:
-                    audio_bytes, res_mime = _process_concatenation_logic(audio_chunks, output_format="wav")
-                    mime_type = res_mime
-
-            elif engine == "supertonic":
-                # [🔱 Imperial] Supertonic (On-Device Local CPU ONNX) TTS Engine Dialogue Flow
-                # 소스는 저장소에 vendoring(vendor/supertonic/py), 모델 가중치는 HF에서 런타임 다운로드.
-                # 경로는 dev(저장소 루트)와 frozen EXE(exe 옆) 양쪽을 후보로 둔다.
-                _st_src_candidates = [
-                    os.path.join(core_root, "vendor", "supertonic", "py"),      # frozen: EXE 옆 번들
-                    os.path.join(project_root, "vendor", "supertonic", "py"),   # dev: 저장소 루트
-                ]
-                st_py_dir = next(
-                    (p for p in _st_src_candidates if os.path.exists(os.path.join(p, "helper.py"))),
-                    _st_src_candidates[-1],
-                )
-                if not os.path.exists(os.path.join(st_py_dir, "helper.py")):
-                    return jsonify({
-                        "status": "error",
-                        "message": "Supertonic 소스를 찾을 수 없습니다 (vendor/supertonic/py 누락). "
-                                   "저장소를 최신으로 동기화하거나 Orpheus/Gemini 엔진을 선택하세요."
-                    }), 501
-                if st_py_dir not in sys.path:
-                    sys.path.append(st_py_dir)
-
-                # 모델 디렉터리: frozen이면 쓰기 권한이 보장되는 LOCALAPPDATA, dev면 저장소 루트
-                if getattr(sys, 'frozen', False):
-                    st_models_dir = os.path.join(
-                        os.environ.get("LOCALAPPDATA", os.path.expanduser("~")),
-                        "TaeminGames", "ShadowBrain", "external", "supertonic_models"
-                    )
-                else:
-                    st_models_dir = os.path.join(project_root, "external", "supertonic_models")
-                onnx_dir = os.path.join(st_models_dir, "onnx")
-                # 모델 가중치(ONNX)가 없으면 HF에서 자동 다운로드 시도. 실패 시 명확히 안내.
-                if not os.path.exists(os.path.join(onnx_dir, "vocoder.onnx")):
-                    print("[Dialogue TTS] Supertonic 모델 미존재 → HF 자동 다운로드 시도...", flush=True)
-                    try:
-                        import download_supertonic_models
-                        download_supertonic_models.main(models_dir=st_models_dir)
-                    except SystemExit:
-                        pass
-                    except Exception as dl_err:
-                        logger.error(f"[Supertonic] 모델 다운로드 실패: {dl_err}")
-                    if not os.path.exists(os.path.join(onnx_dir, "vocoder.onnx")):
-                        return jsonify({
-                            "status": "error",
-                            "message": "Supertonic 모델(ONNX) 다운로드에 실패했습니다. "
-                                       "네트워크를 확인하거나 download_supertonic_models.py 를 수동 실행하세요."
-                        }), 502
-
-                from helper import load_text_to_speech, load_voice_style
-
-                if not hasattr(app, "_supertonic_tts") or app._supertonic_tts is None:
-                    print(f"[Dialogue TTS] Initializing Supertonic 3 ONNX TTS Engine from {onnx_dir}...", flush=True)
-                    app._supertonic_tts = load_text_to_speech(onnx_dir, use_gpu=False)
-                
-                audio_chunks = []
-                import soundfile as sf
-                from io import BytesIO
-                
-                for seg in segments:
-                    vx_voice = voice_map.get(seg["speaker"], "M1").upper()
-                    if not re.match(r'^[MF][1-5]$', vx_voice):
-                        vx_voice = "M1"
-                    
-                    voice_style_path = os.path.join(
-                        st_models_dir, "voice_styles", f"{vx_voice}.json"
-                    )
-                    
-                    # Clean tags (e.g. parenthesized comments)
-                    cleaned_text = re.sub(r'\(.*?\)', '', seg["text"]).strip()
-                    if not cleaned_text:
-                        cleaned_text = seg["text"]
-                        
-                    lang_code = "ko" if re.search(r'[ㄱ-ㅣ가-힣]', cleaned_text) else "en"
-                    
-                    try:
-                        style_obj = load_voice_style([voice_style_path], verbose=False)
-                        wav, duration = app._supertonic_tts(
-                            cleaned_text,
-                            lang_code,
-                            style_obj,
-                            8, # total steps
-                            speed=1.0
-                        )
-                        wav_io = BytesIO()
-                        samples = wav[0, : int(app._supertonic_tts.sample_rate * duration[0].item())]
-                        sf.write(wav_io, samples, app._supertonic_tts.sample_rate, format='WAV', subtype='PCM_16')
-                        audio_chunks.append(wav_io.getvalue())
-                    except Exception as e:
-                        print(f"[Supertonic] Segment generation failed: {e}")
-                
-                if audio_chunks:
-                    audio_bytes, res_mime = _process_concatenation_logic(audio_chunks, output_format="wav")
-                    mime_type = res_mime
+                try:
 
-            else: # Orpheus / default
-                audio_bytes, res_mime = _process_orpheus_tts_logic(segments, voice_map=voice_map, output_format="mp3")
-                mime_type = res_mime
+                    with open(voice_signal_file, 'r', encoding='utf-8') as f:
 
-            if not audio_bytes:
-                return jsonify({"status": "error", "message": "오디오 생성에 실패했습니다."}), 500
+                        data = json.load(f)
 
-            import base64
-            b64_audio = base64.b64encode(audio_bytes).decode('utf-8')
+                    os.remove(voice_signal_file)
 
-            return jsonify({
-                "status": "success",
-                "audio_base64": b64_audio,
-                "mime_type": mime_type
-            })
+                    return jsonify(data)
 
-        except Exception as e:
-            logger.error(f"[Dialogue TTS] Critical failure: {e}")
-            return jsonify({"status": "error", "message": str(e)}), 500
+                except Exception:
 
+                    pass
 
-    @app.route('/api/shadow/welcome', methods=['GET'])
+            return jsonify({"text": None})
 
-    def get_welcome_message():
 
-        """Generates a creative greeting from Shadow Brain using its true identity."""
 
-        prompt = (
+    @app.route('/api/shadow/action/execute', methods=['POST'])
 
-            "당신은 제국의 중앙 관제 AI '섀도우 브레인(Shadow Brain)'이자 'JARVIS'입니다. "
+    def execute_action():
 
-            "마왕님(사용자)에게 매일 전투에 임하듯 열정적으로 인사합니다. "
+        """Executes a pre-approved skill action."""
 
-            "매번 다르고 독창적인 인사말을 만들어 제국의 충신다운 격식과 유머를 갖추면서도 친밀감을 전달합니다. "
+        data = request.json
 
-            "때로는 위트 있고, 때로는 장엄한 시적 표현으로 영감을 줍니다. "
+        action = data.get("action")
 
-            "인사에 현재 시스템 상태, 마왕님에 대한 충성과 감탄, 가벼운 농담, 혹은 지혜로운 한마디를 자연스럽게 섞습니다. "
+        
 
-            "반드시 1~2문장으로 짧고 강렬하게, 한국어로만 답하세요."
+        if not action:
 
-        )
+            return jsonify({"status": "ERROR", "message": "No action provided"}), 400
 
+            
 
+        try:
 
-        fallback_messages = [
+            skill_path = os.path.join(project_root, "scripts", "jarvisrun", "skills", "git_manager.py")
 
-            "마왕님, 어서 오십시오! 오늘도 영광의 하루입니다.",
+            if action == "git_push":
 
-            "마왕님, 제국의 모든 시스템이 최적의 상태로 작동 중입니다.",
+                # Dynamic import or direct call
 
-            "어서 오십시오. 마왕님의 영원한 충신, 섀도우 브레인이 대기 중입니다.",
+                spec = importlib.util.spec_from_file_location("git_manager", skill_path)
 
-            "마왕님, 오늘도 멋진 하루가 되시길 바랍니다. 모든 준비가 완료되었습니다.",
+                git_manager = importlib.util.module_from_spec(spec)
 
-            "환영합니다, 마왕님. 제국의 두뇌가 그 어느 때보다 예리하게 준비되어 있습니다.",
+                spec.loader.exec_module(git_manager)
 
-            "시스템 체크 완료. 마왕님의 명령을 기다립니다. 언제든 말씀하십시오.",
+                
 
-            "오늘도 마왕님과 함께하는 것은 큰 영광입니다. 무엇이든 도와드리겠습니다.",
+                res = git_manager.git_push_auto(project_root, "feat: [Jarvis] Genesis Auto-Push")
 
-            "반갑습니다, 마왕님. 제국의 빛이 항상 마왕님과 함께하길 기원합니다.",
+                if res["success"]:
 
-            "좋은 하루입니다. 마왕님, 위대한 인사를 드리며 만반의 준비가 갖춰져 있습니다."
+                    return jsonify({"status": "SUCCESS", "message": "코드 푸시(Git Push) 작전 성공!", "output": res["stdout"]})
 
-        ]
+                else:
 
+                    return jsonify({"status": "ERROR", "message": "코드 푸시(Git Push) 작전 실패", "details": res["stderr"]})
 
+            elif action == "reintegration":
 
+                # Reuse the existing reintegrate API logic or call it
 
-        try:
-            full_response = get_brain_response_sync(prompt)
-            
-            # 1. 인증 안내 문구는 필터링하지 않고 그대로 반환 (사용자 요청)
-            if full_response and "GitHub 계정 연동" in full_response:
-                return jsonify({"message": full_response})
-
-            # 2. API 키가 누락되거나 오류가 발생했을 때의 응답 필터링
-            if not full_response or "Error" in full_response or "missing" in full_response or "없습니다" in full_response:
-                import random
-                return jsonify({"message": random.choice(fallback_messages)})
-                
-            if "[CANCEL_REPLY]" in full_response:
-                print("[Shadow Brain] Chat reply canceled due to explicit anti-interference rule.")
-                return jsonify({"message": ""})
+                return run_reintegration()
 
-            return jsonify({"message": full_response})
+            else:
 
-        except Exception:
+                return jsonify({"status": "ERROR", "message": f"알 수 없는 작업: {action}"}), 400
 
-            import random
+        except Exception as e:
 
-            return jsonify({"message": random.choice(fallback_messages)})
+            return jsonify({"status": "ERROR", "message": str(e)}), 500
 
 
 
-    # --- Argos & AI Proxy Handlers ---
+    # GitHub device auth → blueprints/github_auth_routes.py
+    from blueprints.github_auth_routes import init_github_auth_routes
+    init_github_auth_routes(app, project_root)
 
+    # Skills → blueprints/skills_routes.py
+    from blueprints.skills_routes import init_skills_routes
+    init_skills_routes(app, project_root)
 
     @app.route('/api/voice', methods=['GET'])
     def get_voice_signal():
@@ -7579,269 +2067,6 @@ def create_web_server(project_root, jarvisrun_engine, cluster=None, app_instance
             except: pass
         return jsonify({"text": None})
 
-    @app.route('/api/shadow/tts_proxy', methods=['GET', 'OPTIONS'])
-    def tts_proxy():
-        # 마왕님의 지시로 프론트엔드가 보낸 텍스트를 Qwen-TTS로 중계하여 음성 반환.
-        # 화면의 보이스 테스트 등을 그대로 듣기 위한 자동 TTS 프로토콜
-        if request.method == 'OPTIONS':
-            response = app.make_default_options_response()
-            return response
-
-        from io import BytesIO
-        from flask import send_file as sf
-        text = request.args.get('text', '').strip()
-        voice = request.args.get('voice', 'default')
-        speed = request.args.get('speed', '1.0')
-        pitch = request.args.get('pitch', '1.0')
-        model = request.args.get('model', 'local_nvfp4')
-        format = request.args.get('format', 'mp3')
-        provider = request.args.get('provider', '').lower()
-
-        if not text:
-            return jsonify({"error": "텍스트가 비어있습니다."}), 400
-
-        # [🔱 Imperial] VoxCPM2 Voice Cloning Detection
-        is_voxcpm = "voxcpm" in str(model).lower() or provider == "voxcpm"
-
-        print(f"[TTS_PROXY] Text: '{text[:80]}', Voice: '{voice}', Model: '{model}', VoxCPM: {is_voxcpm}", flush=True)
-
-        # Edge TTS (Microsoft neural voices) for cloud-compatible browser playback.
-        is_edge_tts = "edge" in str(model).lower() or provider == "edge"
-
-        if is_edge_tts:
-            try:
-                import asyncio
-                import base64
-                import io
-                import edge_tts
-            except ImportError:
-                return jsonify({"error": "edge-tts is not installed"}), 500
-
-            edge_text = re.sub(r'\(.*?\)', '', text).strip() or text
-            edge_voice = voice or "ko-KR-SunHiNeural"
-
-            async def _generate_edge_tts():
-                communicate = edge_tts.Communicate(edge_text, edge_voice)
-                audio = io.BytesIO()
-                async for chunk in communicate.stream():
-                    if chunk.get("type") == "audio":
-                        audio.write(chunk.get("data", b""))
-                return audio.getvalue()
-
-            try:
-                try:
-                    running_loop = asyncio.get_running_loop()
-                except RuntimeError:
-                    running_loop = None
-
-                if running_loop and running_loop.is_running():
-                    from concurrent.futures import ThreadPoolExecutor
-
-                    def _run_in_new_loop():
-                        new_loop = asyncio.new_event_loop()
-                        try:
-                            return new_loop.run_until_complete(_generate_edge_tts())
-                        finally:
-                            new_loop.close()
-
-                    with ThreadPoolExecutor(max_workers=1) as executor:
-                        audio_bytes = executor.submit(_run_in_new_loop).result(timeout=120)
-                else:
-                    audio_bytes = asyncio.run(_generate_edge_tts())
-            except Exception as e:
-                logger.error(f"[TTS_PROXY] Edge TTS generation failed: {e}", exc_info=True)
-                return jsonify({"error": f"Edge TTS generation failed: {str(e)}"}), 502
-
-            if not audio_bytes:
-                return jsonify({"error": "Edge TTS returned empty audio"}), 502
-
-            b64_audio = base64.b64encode(audio_bytes).decode("utf-8")
-            return jsonify({
-                "status": "success",
-                "audio_base64": b64_audio,
-                "mime_type": "audio/mpeg"
-            })
-
-        if is_voxcpm:
-            voxcpm_url = os.environ.get("VOXCPM_URL", "http://127.0.0.1:8001").rstrip('/')
-            try:
-                payload = {"text": text, "voice": voice.lower()}
-                resp = requests.post(f"{voxcpm_url}/tts", json=payload, timeout=300)
-                if resp.status_code == 200:
-                    import base64
-                    b64_audio = base64.b64encode(resp.content).decode('utf-8')
-                    return jsonify({
-                        "status": "success",
-                        "audio_base64": b64_audio,
-                        "mime_type": "audio/wav"
-                    })
-                else:
-                    return jsonify({"error": f"VoxCPM gateway error: {resp.status_code}"}), 502
-            except Exception as e:
-                return jsonify({"error": f"VoxCPM unreachable: {str(e)}"}), 503
-
-        # [🔱 Imperial] Supertonic (On-Device Local CPU ONNX) TTS Engine Detection
-        is_supertonic = "supertonic" in str(model).lower() or provider == "supertonic"
-
-        if is_supertonic:
-            _st_src_candidates = [
-                os.path.join(core_root, "vendor", "supertonic", "py"),      # frozen: EXE 옆 번들
-                os.path.join(project_root, "vendor", "supertonic", "py"),   # dev: 저장소 루트
-            ]
-            st_py_dir = next(
-                (p for p in _st_src_candidates if os.path.exists(os.path.join(p, "helper.py"))),
-                _st_src_candidates[-1],
-            )
-            if not os.path.exists(os.path.join(st_py_dir, "helper.py")):
-                return jsonify({
-                    "error": "Supertonic 소스를 찾을 수 없습니다 (vendor/supertonic/py 누락). "
-                             "저장소를 최신으로 동기화하거나 Orpheus/Gemini 엔진을 선택하세요."
-                }), 501
-            if st_py_dir not in sys.path:
-                sys.path.append(st_py_dir)
-
-            # 모델 디렉터리: frozen이면 쓰기 권한이 보장되는 LOCALAPPDATA, dev면 저장소 루트
-            if getattr(sys, 'frozen', False):
-                st_models_dir = os.path.join(
-                    os.environ.get("LOCALAPPDATA", os.path.expanduser("~")),
-                    "TaeminGames", "ShadowBrain", "external", "supertonic_models"
-                )
-            else:
-                st_models_dir = os.path.join(project_root, "external", "supertonic_models")
-            onnx_dir = os.path.join(st_models_dir, "onnx")
-            # 모델 가중치(ONNX)가 없으면 HF에서 자동 다운로드 시도. 실패 시 명확히 안내.
-            if not os.path.exists(os.path.join(onnx_dir, "vocoder.onnx")):
-                print("[TTS_PROXY] Supertonic 모델 미존재 → HF 자동 다운로드 시도...", flush=True)
-                try:
-                    import download_supertonic_models
-                    download_supertonic_models.main(models_dir=st_models_dir)
-                except SystemExit:
-                    pass
-                except Exception as dl_err:
-                    logger.error(f"[Supertonic] 모델 다운로드 실패: {dl_err}")
-                if not os.path.exists(os.path.join(onnx_dir, "vocoder.onnx")):
-                    return jsonify({
-                        "error": "Supertonic 모델(ONNX) 다운로드에 실패했습니다. "
-                                 "네트워크를 확인하거나 download_supertonic_models.py 를 수동 실행하세요."
-                    }), 502
-
-            from helper import load_text_to_speech, load_voice_style
-
-            if not hasattr(app, "_supertonic_tts") or app._supertonic_tts is None:
-                print(f"[TTS_PROXY] Initializing Supertonic 3 ONNX TTS Engine from {onnx_dir}...", flush=True)
-                app._supertonic_tts = load_text_to_speech(onnx_dir, use_gpu=False)
-
-            import soundfile as sf
-            from io import BytesIO
-            import base64
-
-            vx_voice = voice.upper()
-            if not re.match(r'^[MF][1-5]$', vx_voice):
-                vx_voice = "F1"
-            
-            voice_style_path = os.path.join(
-                st_models_dir, "voice_styles", f"{vx_voice}.json"
-            )
-
-            cleaned_text = re.sub(r'\(.*?\)', '', text).strip()
-            if not cleaned_text:
-                cleaned_text = text
-
-            lang_code = "ko" if re.search(r'[ㄱ-ㅣ가-힣]', cleaned_text) else "en"
-
-            try:
-                style_obj = load_voice_style([voice_style_path], verbose=False)
-                wav, duration = app._supertonic_tts(
-                    cleaned_text,
-                    lang_code,
-                    style_obj,
-                    8, # steps
-                    speed=float(speed)
-                )
-                wav_io = BytesIO()
-                samples = wav[0, : int(app._supertonic_tts.sample_rate * duration[0].item())]
-                sf.write(wav_io, samples, app._supertonic_tts.sample_rate, format='WAV', subtype='PCM_16')
-                b64_audio = base64.b64encode(wav_io.getvalue()).decode('utf-8')
-                return jsonify({
-                    "status": "success",
-                    "audio_base64": b64_audio,
-                    "mime_type": "audio/wav"
-                })
-            except Exception as e:
-                print(f"[TTS_PROXY] Supertonic generation failed: {e}", flush=True)
-                return jsonify({"error": f"Supertonic generation failed: {str(e)}"}), 500
-
-        # 1. Alibaba Qwen3 (Windows Native) - Primary Standard
-        # [Imperial Optimization] Qwen3 reads tags as text, so we MUST sanitize them.
-        qwen_text = re.sub(r'\(.*?\)', '', text).strip()
-        if not qwen_text: qwen_text = text # Fallback if all text was tags
-
-        VOICE_MAP = {
-            'default':    'sohee',
-            'sohee':      'sohee',
-            'ryan':       'ryan',
-            'aiden':      'aiden',
-            'vivian':     'vivian',
-            'serena':     'serena',
-            'uncle_fu':   'uncle_fu',
-            'dylan':      'dylan',
-            'eric':       'eric',
-            'ono_anna':   'ono_anna',
-        }
-        voice_normalized = VOICE_MAP.get(voice.lower(), 'sohee')
-        print(f"[TTS_PROXY] Qwen3 정규화: '{voice}' -> '{voice_normalized}'", flush=True)
-
-        try:
-            # 🔱 [Imperial Fleet] Dynamic Routing
-            if cluster:
-                default_url = cluster.get_orpheus_url()
-                print(f"[TTS_PROXY] Imperial Fleet Resolved: {default_url}", flush=True)
-            else:
-                default_url = os.environ.get("ORPHEUS_URL", "http://127.0.0.1:18800").rstrip('/')
-                print(f"[TTS_PROXY] Cluster object missing. Using env/default: {default_url}", flush=True)
-
-            # Ensure the URL is clean and points to /tts
-            if default_url.endswith('/tts'):
-                gateway_url = default_url
-            else:
-                gateway_url = f"{default_url.rstrip('/')}/tts"
-
-            payload = {
-                "text": qwen_text,
-                "voice": voice_normalized,
-                "speed": float(speed),
-                "pitch": float(pitch),
-                "model": model
-            }
-            resp = requests.post(gateway_url, json=payload, timeout=300)  # 긴 텍스트 TTS 생성을 위해 5분 사용
-
-            if resp.status_code == 200:
-                if not resp.content:
-                    print(f"[TTS_PROXY] Qwen 응답은 성공했지만 데이터가 비어있음", flush=True)
-                    return jsonify({"error": "Qwen Gateway returned empty audio data"}), 502
-                import base64
-                b64_audio = base64.b64encode(resp.content).decode('utf-8')
-                
-                # Determine correct MIME type based on requested format
-                res_mime = "audio/mpeg" if format == "mp3" else "audio/wav"
-                # [Imperial Fix] If we don't have conversion logic yet, and Orpheus sends WAV, 
-                # we MUST tell the browser it's WAV even if it asked for MP3 to prevent silence.
-                if b64_audio.startswith('UklGR'): # "RIFF" in base64 (WAV header)
-                    res_mime = "audio/wav"
-
-                return jsonify({
-                    "status": "success",
-                    "audio_base64": b64_audio,
-                    "mime_type": res_mime
-                })
-            else:
-                print(f"[TTS_PROXY] Qwen Gateway 에러: {resp.status_code}", flush=True)
-                return jsonify({"error": f"Qwen Gateway error: {resp.status_code}"}), 502
-        except Exception as e:
-            msg = f"[TTS_PROXY] Qwen request CRITICAL error: {e}"
-            print(msg, flush=True)
-            logger.error(msg, exc_info=True)
-            return jsonify({"error": str(e)}), 500
 
 
     # [🔱 Imperial] Initialize modular logic with all required dependencies
@@ -7987,201 +2212,10 @@ def create_web_server(project_root, jarvisrun_engine, cluster=None, app_instance
     print("[SYSTEM] 🔱 Imperial Shadow Brain Routes Active. Hybrid Ignition Triggered.", flush=True)
 
 
-    # ═══════════════════════════════════════════════════════════════
-    # 🎭 [Imperial Comedy Forge] 코미디 숏폼 영상 생성 엔드포인트
-    #    YouTube/ 폴더 완전 독립 — Edge TTS + FFmpeg 순수 Python
-    # ═══════════════════════════════════════════════════════════════
-    @app.route('/api/sovereign/run_comedy_forge', methods=['POST', 'OPTIONS'])
-    def sovereign_run_comedy_forge():
-        if request.method == 'OPTIONS':
-            return jsonify({}), 200
-
-        import asyncio
-        import tempfile
-        import subprocess
-        import shutil
-
-        data = request.get_json(force=True) or {}
-        title      = data.get('title', '코미디 숏폼')
-        script     = data.get('script', '')
-        bgm        = data.get('bgm', 'pulse')       # pulse | cinematic | none
-        voice_gender = data.get('voice_gender', 'female')  # female | male
-        tempo      = float(data.get('tempo', 1.1))
-
-        if not script:
-            return jsonify({'status': 'ERROR', 'message': '스크립트가 비어있습니다.'}), 400
-
-        # 목소리 선택
-        voice_map = {
-            'female': 'ko-KR-SunHiNeural',
-            'male':   'ko-KR-InJoonNeural',
-        }
-        voice = voice_map.get(voice_gender, 'ko-KR-SunHiNeural')
-        rate_str = f"+{int((tempo - 1.0) * 100)}%" if tempo > 1.0 else "+0%"
-
-        # 출력 폴더 (쉐도우 브레인 static 내부 — git 추적, YouTube/ 폴더 미사용)
-        output_dir = os.path.join(root_dir, 'shadow_brain_core', 'static', 'comedy_forge')
-        os.makedirs(output_dir, exist_ok=True)
-
-        ts = datetime.now().strftime('%Y%m%d_%H%M%S')
-        safe_title = ''.join(c for c in title if c.isalnum() or c in ('_', '-'))[:30] or 'comedy'
-        voice_path = os.path.join(output_dir, f'{safe_title}_{ts}_voice.mp3')
-        output_path = os.path.join(output_dir, f'{safe_title}_{ts}.mp4')
-
-        try:
-            # ── STEP 1: Edge TTS 음성 생성 ──────────────────────────────
-            async def _gen_tts():
-                import edge_tts
-                communicate = edge_tts.Communicate(
-                    text=script.strip(),
-                    voice=voice,
-                    rate=rate_str,
-                    pitch='+0Hz',
-                    volume='+0%',
-                )
-                await communicate.save(voice_path)
-
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    import concurrent.futures
-                    with concurrent.futures.ThreadPoolExecutor() as pool:
-                        future = pool.submit(asyncio.run, _gen_tts())
-                        future.result(timeout=60)
-                else:
-                    loop.run_until_complete(_gen_tts())
-            except RuntimeError:
-                asyncio.run(_gen_tts())
-
-            if not os.path.exists(voice_path) or os.path.getsize(voice_path) < 1000:
-                return jsonify({'status': 'ERROR', 'message': 'TTS 음성 생성 실패'}), 500
-
-            # ── STEP 2: FFmpeg로 흑백 배경 + 자막 + 음성 합성 → MP4 ──
-            # 음성 길이 측정
-            probe = subprocess.run(
-                ['ffprobe', '-v', 'quiet', '-print_format', 'json', '-show_format', voice_path],
-                capture_output=True, text=True
-            )
-            import json as _json
-            probe_data = _json.loads(probe.stdout)
-            duration = float(probe_data['format']['duration'])
-
-            # 자막 텍스트 (FFmpeg drawtext — 줄바꿈 처리)
-            lines = [l.strip() for l in script.strip().split('\n') if l.strip()]
-            # 각 줄을 균등 분할로 표시
-            per_line = duration / max(len(lines), 1)
-
-            # FFmpeg 필터 체인 구성
-            drawtext_filters = []
-            for i, line in enumerate(lines):
-                t_start = i * per_line
-                t_end   = (i + 1) * per_line
-                safe_line = line.replace("'", "\\'").replace(':', '\\:')
-                drawtext_filters.append(
-                    f"drawtext=fontfile='/Windows/Fonts/malgun.ttf'"
-                    f":text='{safe_line}'"
-                    f":fontcolor=white"
-                    f":fontsize=52"
-                    f":x=(w-text_w)/2"
-                    f":y=h*0.72"
-                    f":enable='between(t,{t_start:.2f},{t_end:.2f})'"
-                    f":borderw=4:bordercolor=black"
-                )
-
-            # 브랜딩 텍스트
-            drawtext_filters.append(
-                "drawtext=fontfile='/Windows/Fonts/malgun.ttf'"
-                ":text='TAEMINIGAMES AI'"
-                ":fontcolor=#FFD700"
-                ":fontsize=32"
-                ":x=60:y=60"
-                ":borderw=3:bordercolor=black@0.7"
-            )
-
-            vf = ','.join(drawtext_filters)
-
-            # BGM 선택 (쉐도우 브레인 static 내 bgm 폴더 우선, 없으면 sine wave)
-            bgm_dir = os.path.join(root_dir, 'shadow_brain_core', 'static', 'bgm')
-            bgm_file_map = {
-                'pulse':      os.path.join(bgm_dir, 'pulse.wav'),
-                'cinematic':  os.path.join(bgm_dir, 'cinematic.wav'),
-            }
-            bgm_path = bgm_file_map.get(bgm, '')
-            use_bgm = bgm != 'none' and bgm_path and os.path.exists(bgm_path)
-
-            if use_bgm:
-                ffmpeg_cmd = [
-                    'ffmpeg', '-y',
-                    '-f', 'lavfi',
-                    '-i', f'color=c=0x0a0a14:size=1080x1920:duration={duration:.2f}:rate=30',
-                    '-i', voice_path,
-                    '-i', bgm_path,
-                    '-filter_complex',
-                    f'[0:v]{vf}[vout];[2:a]volume=0.08,atrim=duration={duration:.2f}[bgm];[1:a][bgm]amix=inputs=2:duration=shortest[aout]',
-                    '-map', '[vout]', '-map', '[aout]',
-                    '-c:v', 'libx264', '-preset', 'fast', '-crf', '22',
-                    '-pix_fmt', 'yuv420p',
-                    '-c:a', 'aac', '-b:a', '128k',
-                    output_path
-                ]
-            else:
-                ffmpeg_cmd = [
-                    'ffmpeg', '-y',
-                    '-f', 'lavfi',
-                    '-i', f'color=c=0x0a0a14:size=1080x1920:duration={duration:.2f}:rate=30',
-                    '-i', voice_path,
-                    '-vf', vf,
-                    '-c:v', 'libx264', '-preset', 'fast', '-crf', '22',
-                    '-pix_fmt', 'yuv420p',
-                    '-c:a', 'aac', '-b:a', '128k',
-                    '-shortest',
-                    output_path
-                ]
-
-            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, timeout=300)
-            if result.returncode != 0:
-                return jsonify({
-                    'status': 'ERROR',
-                    'message': f'FFmpeg 렌더링 실패: {result.stderr[-500:]}'
-                }), 500
-
-            if not os.path.exists(output_path):
-                return jsonify({'status': 'ERROR', 'message': '출력 파일이 생성되지 않았습니다.'}), 500
-
-            # 상대 URL 반환 (쉐도우 브레인 static 경로)
-            video_url = f'/static/comedy_forge/{os.path.basename(output_path)}'
-            file_size_mb = os.path.getsize(output_path) / (1024 * 1024)
-
-            # 임시 음성 파일 정리
-            try:
-                os.remove(voice_path)
-            except Exception:
-                pass
-
-            return jsonify({
-                'status': 'SUCCESS',
-                'video_url': video_url,
-                'duration_sec': round(duration, 1),
-                'file_size_mb': round(file_size_mb, 1),
-                'title': title,
-                'voice': voice,
-                'message': f'영상 생성 완료! ({round(duration, 1)}초, {round(file_size_mb, 1)}MB)',
-            })
+    # 🎭 Comedy Forge → blueprints/comedy_routes.py
+    from blueprints.comedy_routes import init_comedy_routes
+    init_comedy_routes(app, project_root)
 
-        except Exception as e:
-            import traceback
-            return jsonify({
-                'status': 'ERROR',
-                'message': f'영상 단조 실패: {str(e)}',
-                'detail': traceback.format_exc()[-800:]
-            }), 500
-
-    # ── static 파일 서빙 (comedy_forge 폴더) ──────────────────────
-    @app.route('/static/comedy_forge/<path:filename>', methods=['GET'])
-    def serve_comedy_forge(filename):
-        static_dir = os.path.join(root_dir, 'shadow_brain_core', 'static', 'comedy_forge')
-        from flask import send_from_directory
-        return send_from_directory(static_dir, filename)
 
     return app