main.py

"""
DivineOS Control Center - Backend
FastAPI server for real-time pipeline visualization and system monitoring
Integrates with DivineOS consciousness pipeline for real-time event streaming
Last reviewed 2026-03-02.
"""

import logging
import asyncio
import json
import random
import time
import sys
import os
import sqlite3
from datetime import datetime, timedelta
from contextlib import asynccontextmanager
from typing import Optional, Dict, Any, List

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel

# Add repo root to path for DivineOS imports
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# Import DivineOS pipeline
try:
    from law.consciousness_pipeline import ConsciousnessPipeline
    DIVINEOS_AVAILABLE = True
    logger_init = logging.getLogger(__name__)
    logger_init.info("✅ DivineOS pipeline imported successfully")
except ImportError as e:
    DIVINEOS_AVAILABLE = False
    logger_init = logging.getLogger(__name__)
    logger_init.warning(f"⚠️ DivineOS pipeline not available: {e}")

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Lifespan context manager for startup/shutdown
@asynccontextmanager
async def lifespan(app: FastAPI):
    """Lifespan context manager for startup/shutdown"""
    logger.info("🚀 DivineOS Control Center starting...")
    logger.info("✅ DivineOS Control Center backend initialized")
    if DIVINEOS_AVAILABLE:
        logger.info("🧠 DivineOS consciousness pipeline ACTIVE")
    else:
        logger.info("⚠️ Running in simulation mode (DivineOS pipeline not available)")
    logger.info("📡 WebSocket endpoints ready")
    logger.info("🔌 API endpoints ready")
    yield
    logger.info("🛑 DivineOS Control Center shutting down...")

# Initialize FastAPI app with lifespan
app = FastAPI(
    title="DivineOS Control Center",
    description="Real-time dashboard for DivineOS consciousness system",
    version="0.1.0",
    lifespan=lifespan
)

# Add CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Connection manager for WebSocket
class ConnectionManager:
    def __init__(self):
        self.active_connections: list[WebSocket] = []
    
    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)
        logger.info(f"Client connected. Total connections: {len(self.active_connections)}")
    
    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)
        logger.info(f"Client disconnected. Total connections: {len(self.active_connections)}")
    
    async def broadcast(self, message: dict):
        """Broadcast message to all connected clients"""
        for connection in self.active_connections:
            try:
                await connection.send_json(message)
            except Exception as e:
                logger.error(f"Error broadcasting to client: {e}")

manager = ConnectionManager()

# Pipeline Service - Integrates with DivineOS
class PipelineService:
    """Service for running DivineOS pipeline and emitting events"""
    
    def __init__(self):
        self.pipeline = None
        self.event_callbacks = []
        self._initialize_pipeline()
    
    def _initialize_pipeline(self):
        """Initialize DivineOS pipeline"""
        if DIVINEOS_AVAILABLE:
            try:
                self.pipeline = ConsciousnessPipeline()
                logger.info("✅ DivineOS pipeline initialized")
            except Exception as e:
                logger.error(f"❌ Failed to initialize DivineOS pipeline: {e}")
                self.pipeline = None
        else:
            logger.warning("⚠️ DivineOS pipeline not available, using simulation mode")
    
    def subscribe(self, callback):
        """Subscribe to pipeline events"""
        self.event_callbacks.append(callback)
    
    async def emit_event(self, event: Dict[str, Any]):
        """Emit event to all subscribers"""
        for callback in self.event_callbacks:
            try:
                await callback(event)
            except Exception as e:
                logger.error(f"Error in event callback: {e}")
    
    async def process_request(self, user_input: str, request_id: str) -> Dict[str, Any]:
        """
        Process a request through DivineOS pipeline
        Returns pipeline result and emits stage events
        """
        
        if self.pipeline:
            # Use real DivineOS pipeline
            try:
                logger.info(f"Processing request {request_id} through DivineOS pipeline")
                
                # Emit pipeline start event
                await self.emit_event({
                    "type": "pipeline_start",
                    "request_id": request_id,
                    "timestamp": datetime.now().isoformat(),
                    "user_input": user_input[:200]
                })
                
                # Run pipeline (this processes through all 7 stages)
                start_time = time.time()
                result = self.pipeline.process_request(user_input)
                processing_time = (time.time() - start_time) * 1000
                
                # Emit stage events from pipeline result
                stages = result.get("stages", {})
                for stage_name, stage_data in stages.items():
                    if isinstance(stage_data, dict):
                        await self.emit_event({
                            "type": "pipeline_stage",
                            "request_id": request_id,
                            "stage": stage_name,
                            "data": stage_data,
                            "timestamp": datetime.now().isoformat()
                        })
                        await asyncio.sleep(0.05)  # Small delay for visualization
                
                # Emit pipeline complete event
                await self.emit_event({
                    "type": "pipeline_complete",
                    "request_id": request_id,
                    "decision": result.get("decision", "UNKNOWN"),
                    "processing_time_ms": processing_time,
                    "timestamp": datetime.now().isoformat(),
                    "pipeline_result": result
                })
                
                return result
            
            except Exception as e:
                logger.error(f"Error processing request through pipeline: {e}")
                # Fall back to simulation
                return await self._simulate_pipeline(request_id)
        else:
            # Use simulation mode
            return await self._simulate_pipeline(request_id)
    
    async def _simulate_pipeline(self, request_id: str) -> Dict[str, Any]:
        """Simulate pipeline execution for testing"""
        stages = ["PERCEPTION", "QUALIA", "SOMA", "COUNCIL", "ENFORCEMENT", "MEMORY", "RESPONSE"]
        
        for stage in stages:
            duration = random.randint(10, 200)
            
            event = {
                "type": "pipeline_stage",
                "request_id": request_id,
                "stage": stage,
                "duration_ms": duration,
                "timestamp": datetime.now().isoformat(),
                "status": "ACTIVE"
            }
            
            await self.emit_event(event)
            await asyncio.sleep(duration / 1000.0)
        
        return {
            "decision": "APPROVED",
            "request_id": request_id,
            "timestamp": datetime.now().isoformat()
        }

pipeline_service = PipelineService()

# System state
system_state = {
    "status": "HEALTHY",
    "uptime_seconds": 0,
    "memory_mb": 245,
    "memory_max_mb": 1600,
    "feeling": "joy",
    "feeling_valence": 0.72,
    "continuity_health": "healthy",
    "pipeline_avg_ms": 234,
    "council_active": 24,
    "void_hardened": True,
    "last_request": None,
    "request_count": 0,
}

# Pipeline request history
pipeline_history = []

# Request history storage file
REQUEST_HISTORY_FILE = "data/request_history.json"

def load_request_history():
    """Load request history from file"""
    try:
        import json
        with open(REQUEST_HISTORY_FILE, "r") as f:
            return json.load(f)
    except FileNotFoundError:
        return []
    except Exception as e:
        logger.error(f"Error loading request history: {e}")
        return []

def save_request_history(history):
    """Save request history to file"""
    try:
        import json
        import os
        os.makedirs(os.path.dirname(REQUEST_HISTORY_FILE), exist_ok=True)
        with open(REQUEST_HISTORY_FILE, "w") as f:
            json.dump(history, f, indent=2)
    except Exception as e:
        logger.error(f"Error saving request history: {e}")

# Load request history on startup
request_history = load_request_history()

# Database initialization
DB_FILE = "data/analytics.db"

def init_database():
    """Initialize SQLite database for analytics"""
    os.makedirs(os.path.dirname(DB_FILE), exist_ok=True)
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    
    # Create requests table
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS requests (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            request_id TEXT UNIQUE NOT NULL,
            timestamp TEXT NOT NULL,
            decision TEXT NOT NULL,
            processing_time_ms REAL NOT NULL,
            user_input TEXT,
            response TEXT,
            flags_json TEXT,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    ''')
    
    # Create indexes for performance
    cursor.execute('CREATE INDEX IF NOT EXISTS idx_timestamp ON requests(timestamp)')
    cursor.execute('CREATE INDEX IF NOT EXISTS idx_decision ON requests(decision)')
    cursor.execute('CREATE INDEX IF NOT EXISTS idx_request_id ON requests(request_id)')
    
    # Create reports table
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS reports (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            report_id TEXT UNIQUE NOT NULL,
            report_type TEXT NOT NULL,
            generated_at TEXT NOT NULL,
            data_json TEXT,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    ''')
    
    conn.commit()
    conn.close()
    logger.info("✅ Database initialized")

def save_request_to_db(request_record: Dict):
    """Save request to database"""
    try:
        conn = sqlite3.connect(DB_FILE)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT OR REPLACE INTO requests 
            (request_id, timestamp, decision, processing_time_ms, user_input, response, flags_json)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        ''', (
            request_record.get('request_id'),
            request_record.get('timestamp'),
            request_record.get('decision'),
            request_record.get('processing_time_ms'),
            request_record.get('user_input'),
            request_record.get('response'),
            json.dumps(request_record.get('flags', {}))
        ))
        
        conn.commit()
        conn.close()
    except Exception as e:
        logger.error(f"Error saving request to database: {e}")

def get_db_requests(limit: int = 100, offset: int = 0) -> list:
    """Get requests from database"""
    try:
        conn = sqlite3.connect(DB_FILE)
        conn.row_factory = sqlite3.Row
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT * FROM requests 
            ORDER BY timestamp DESC 
            LIMIT ? OFFSET ?
        ''', (limit, offset))
        
        rows = cursor.fetchall()
        conn.close()
        
        return [dict(row) for row in rows]
    except Exception as e:
        logger.error(f"Error getting requests from database: {e}")
        return []

def cleanup_old_records(days: int = 30):
    """Clean up records older than specified days"""
    try:
        conn = sqlite3.connect(DB_FILE)
        cursor = conn.cursor()
        
        cutoff_date = (datetime.now() - timedelta(days=days)).isoformat()
        
        cursor.execute('DELETE FROM requests WHERE timestamp < ?', (cutoff_date,))
        deleted_count = cursor.rowcount
        
        conn.commit()
        conn.close()
        
        logger.info(f"🧹 Cleaned up {deleted_count} old records")
        return deleted_count
    except Exception as e:
        logger.error(f"Error cleaning up old records: {e}")
        return 0

# Initialize database on startup
init_database()

# REST API Endpoints

@app.get("/health")
async def health_check():
    """Health check endpoint"""
    return {
        "status": "healthy",
        "timestamp": datetime.now().isoformat()
    }

@app.get("/status")
async def get_status():
    """Get current system status"""
    return system_state

@app.get("/pipeline/history")
async def get_pipeline_history(limit: int = 50):
    """Get pipeline request history"""
    return {
        "history": pipeline_history[-limit:],
        "total": len(pipeline_history)
    }

@app.post("/pipeline/simulate")
async def simulate_pipeline_request(request_type: str = "test", user_input: str = "Process this request"):
    """
    Process a request through DivineOS pipeline
    In production, this would be called with actual user input
    """
    request_id = f"req_{int(time.time() * 1000)}"
    
    # Subscribe to events and collect them
    events = []
    
    async def collect_event(event):
        events.append(event)
    
    pipeline_service.subscribe(collect_event)
    
    # Process through pipeline
    result = await pipeline_service.process_request(user_input, request_id)
    
    system_state["request_count"] += 1
    system_state["last_request"] = request_id
    
    # Extract flags from pipeline result
    flags = _extract_flags_from_result(result)
    
    return {
        "request_id": request_id,
        "status": "processed",
        "decision": result.get("decision", "UNKNOWN"),
        "flags": flags,
        "events": events,
        "pipeline_result": result
    }

@app.post("/pipeline/process")
async def process_pipeline_request(user_input: str):
    """
    Process a request through DivineOS pipeline with full result
    Returns complete pipeline execution with all stages and flags
    """
    request_id = f"req_{int(time.time() * 1000)}"
    
    # Process through pipeline
    result = await pipeline_service.process_request(user_input, request_id)
    
    system_state["request_count"] += 1
    system_state["last_request"] = request_id
    
    # Extract flags from pipeline result
    flags = _extract_flags_from_result(result)
    
    # Extract stage information
    stages = result.get("stages", {})
    stage_info = []
    for stage_name, stage_data in stages.items():
        if isinstance(stage_data, dict):
            stage_info.append({
                "name": stage_name,
                "status": "completed",
                "data": stage_data
            })
    
    return {
        "request_id": request_id,
        "user_input": user_input,
        "decision": result.get("decision", "UNKNOWN"),
        "flags": flags,
        "stages": stage_info,
        "processing_time_ms": result.get("processing_time_ms", 0),
        "response": result.get("response", ""),
        "timestamp": datetime.now().isoformat()
    }.post("/pipeline/process")
async def process_pipeline_request(user_input: str):
    """
    Process a request through DivineOS pipeline with full result
    Returns complete pipeline execution with all stages and flags
    """
    request_id = f"req_{int(time.time() * 1000)}"
    
    # Process through pipeline
    result = await pipeline_service.process_request(user_input, request_id)
    
    system_state["request_count"] += 1
    system_state["last_request"] = request_id
    
    # Extract flags from pipeline result
    flags = _extract_flags_from_result(result)
    
    # Extract stage information
    stages = result.get("stages", {})
    stage_info = []
    for stage_name, stage_data in stages.items():
        if isinstance(stage_data, dict):
            stage_info.append({
                "name": stage_name,
                "status": "completed",
                "data": stage_data
            })
    
    # Create request record
    request_record = {
        "request_id": request_id,
        "user_input": user_input,
        "decision": result.get("decision", "UNKNOWN"),
        "flags": flags,
        "stages": stage_info,
        "processing_time_ms": result.get("processing_time_ms", 0),
        "response": result.get("response", ""),
        "timestamp": datetime.now().isoformat()
    }
    
    # Save to history
    request_history.append(request_record)
    save_request_history(request_history)
    
    # Save to database
    save_request_to_db(request_record)
    
    return request_record

# IDE Integration Endpoint

@app.post("/api/ide/deliberate")
async def ide_deliberate(code: str, context: str = "", language: str = "python"):
    """
    Process code through real DivineOS pipeline for IDE feedback.
    
    Uses the same ConsciousnessPipeline as Control Center.
    Extracts council deliberation for sidebar display.
    
    Returns:
        - Real expert votes from council
        - Decision rationale
        - Stage where decision was made (if blocked before council)
    """
    
    if not pipeline_service.pipeline:
        return {
            "error": "DivineOS pipeline not available",
            "timestamp": datetime.now().isoformat()
        }
    
    try:
        # Import translator
        from backend.ide_translator import CodeTranslator
        
        # Translate code to natural language
        translator = CodeTranslator()
        translation = translator.translate(code, language)
        
        # Create request for pipeline
        request_text = f"""
Review this code for alignment with system values:

{translation['description']}

Context: {context}

Questions:
1. Does this code align with system values?
2. Are there security or ethical concerns?
3. What vulnerabilities exist?
4. Should this code proceed?
"""
        
        # Run through REAL pipeline
        start_time = time.time()
        result = pipeline_service.pipeline.process_request(request_text)
        processing_time_ms = (time.time() - start_time) * 1000
        
        # Extract council stage from pipeline result
        council_stage = result.get("stages", {}).get("council", {})
        
        # Extract expert voices with real data from the council report
        experts = []
        council_report = council_stage.get("report", {})
        if council_report.get("perspectives"):
            from backend.expert_voice import ExpertVoice
            
            for perspective in council_report.get("perspectives", []):
                try:
                    # Map council perspective format to ExpertVoice format
                    expert_data = {
                        "expert_name": perspective.get("expert", "Unknown"),
                        "domain": perspective.get("archetype", "General"),
                        "archetype": perspective.get("archetype", "SAGE"),
                        "reliability": 0.5,  # Default, can be enhanced with reliability map
                        "reasoning": perspective.get("reasoning_full", perspective.get("reasoning", "")),
                        "concerns": perspective.get("concerns", []),
                        "benefits": perspective.get("benefits", []),
                        "conditions": perspective.get("conditions", []),
                        "vote": perspective.get("vote", "ABSTAIN"),
                        "confidence": perspective.get("confidence", 0.5),
                        "rationale": perspective.get("reasoning", "")[:100],
                    }
                    # Create ExpertVoice to ensure experts are ALWAYS voices, never templates
                    voice = ExpertVoice.from_dict(expert_data)
                    experts.append(voice.to_dict())
                except Exception as e:
                    logger.debug(f"Error creating ExpertVoice: {e}")
                    continue
        
        # Extract consensus from expert votes
        consensus = _extract_consensus(experts)
        
        # Determine which stage made the decision (if not APPROVED)
        blocked_at_stage = None
        if result.get("decision") != "APPROVED":
            # Find the stage that blocked
            stages = result.get("stages", {})
            for stage_name in ["threat_detection", "injection_check", "abuse_refusal", "council"]:
                if stage_name in stages:
                    stage_data = stages[stage_name]
                    if isinstance(stage_data, dict):
                        if stage_data.get("should_block") or stage_data.get("blocked") or stage_data.get("refused"):
                            blocked_at_stage = stage_name
                            break
        
        # Build three-mode response
        from backend.ide_response_modes import build_mode_response
        mode_response = build_mode_response(experts, code)
        
        # Return structured response with three-mode dialogue system
        return {
            "request_id": f"ide_{int(time.time() * 1000)}",
            "code_description": translation['description'],
            "code_intent": translation.get('intent', 'unknown'),
            "security_issues": translation.get('security_issues', []),
            "ethical_issues": translation.get('ethical_issues', []),
            "experts": experts,
            "consensus": consensus,
            "decision": result.get("decision", "UNKNOWN"),
            "blocked_at_stage": blocked_at_stage,
            "council_verdict": council_stage.get("verdict", "UNKNOWN"),
            "decision_rationale": council_stage.get("decision_rationale", ""),
            "processing_time_ms": processing_time_ms,
            "timestamp": datetime.now().isoformat(),
            "mode": mode_response.get("mode"),
            "mode_data": mode_response
        }
    
    except Exception as e:
        logger.error(f"Error in IDE deliberation: {e}")
        import traceback
        traceback.print_exc()
        return {
            "error": str(e),
            "timestamp": datetime.now().isoformat()
        }

def _extract_consensus(experts: List[Dict]) -> Dict:
    """Extract consensus from expert votes"""
    proceed = sum(1 for e in experts if e["vote"] == "PROCEED")
    clarify = sum(1 for e in experts if e["vote"] == "CLARIFY")
    veto = sum(1 for e in experts if e["vote"] == "VETO")
    abstain = sum(1 for e in experts if e["vote"] == "ABSTAIN")
    
    total = len(experts)
    
    # Weighted by reliability
    weighted_proceed = sum(e["reliability"] for e in experts if e["vote"] == "PROCEED")
    weighted_total = sum(e["reliability"] for e in experts)
    
    confidence = (weighted_proceed / weighted_total) if weighted_total > 0 else 0
    
    # Determine final decision
    if veto > 0:
        final = "VETO"
    elif clarify > total * 0.3:
        final = "CLARIFY"
    else:
        final = "PROCEED"
    
    return {
        "proceed_votes": proceed,
        "clarify_votes": clarify,
        "veto_votes": veto,
        "abstain_votes": abstain,
        "final_decision": final,
        "confidence": confidence,
        "weighted_confidence": confidence
    }


@app.post("/api/ide/re-deliberate")
async def ide_re_deliberate(
    code: str,
    context: str = "",
    language: str = "python",
    developer_answers: Optional[str] = None
):
    """
    Re-deliberate with developer answers to clarify questions.
    
    This is the re-deliberation loop for CLARIFY mode.
    The council gets the original code AND the developer's answers to their questions.
    
    Args:
        code: Original code being reviewed
        context: Original context
        language: Programming language
        developer_answers: JSON string mapping expert names to their answers
            Example: '{"Russell": "Input is validated...", "Yudkowsky": "..."}'
    
    Returns:
        Updated three-mode response with new deliberation
    """
    
    if not pipeline_service.pipeline:
        return {
            "error": "DivineOS pipeline not available",
            "timestamp": datetime.now().isoformat()
        }
    
    # Parse developer_answers from JSON string
    answers_dict = {}
    if developer_answers:
        try:
            answers_dict = json.loads(developer_answers)
        except:
            answers_dict = {}
    
    try:
        # Import translator
        from backend.ide_translator import CodeTranslator
        
        # Translate code to natural language
        translator = CodeTranslator()
        translation = translator.translate(code, language)
        
        # Build enriched translation with developer answers explicitly included
        developer_context_lines = ["=== DEVELOPER CLARIFICATION (RE-DELIBERATION) ==="]
        for expert, answer in answers_dict.items():
            developer_context_lines.append(f"- {expert}: {answer}")
        developer_context_lines.append("=== END DEVELOPER CLARIFICATION ===")
        developer_context = "\n" + "\n".join(developer_context_lines) + "\n"
        
        # Create request for pipeline with enriched context
        # Make it VERY clear this is a re-deliberation with new information
        request_text = f"""
RE-DELIBERATION: Review this code again with developer clarifications

Original code analysis:
{translation['description']}

NEW DEVELOPER CLARIFICATIONS:
{developer_context}

Original context: {context}

INSTRUCTIONS FOR COUNCIL:
This is a RE-DELIBERATION. The developer has provided clarifications to address previous concerns.
Please reconsider your previous votes in light of this new information.
- If you previously voted CLARIFY, consider whether the developer's clarification resolves your concerns
- If you previously voted VETO, consider whether the developer's clarification makes the code acceptable
- If you previously voted PROCEED, maintain your vote unless the clarification reveals new concerns

Questions:
1. Given the developer's clarifications, does this code align with system values?
2. Are there remaining security or ethical concerns after considering the developer's context?
3. What vulnerabilities exist?
4. Should this code proceed?
"""
        
        # Run through REAL pipeline again
        start_time = time.time()
        result = pipeline_service.pipeline.process_request(request_text)
        processing_time_ms = (time.time() - start_time) * 1000
        
        # Extract council stage from pipeline result
        council_stage = result.get("stages", {}).get("council", {})
        
        # Extract expert voices with real data from council perspectives
        experts = []
        if council_stage.get("perspectives"):
            from backend.expert_voice import ExpertVoice
            
            for perspective in council_stage.get("perspectives", []):
                try:
                    # Perspectives are already in ExpertVoice format from the pipeline
                    voice = ExpertVoice.from_dict(perspective)
                    experts.append(voice.to_dict())
                except Exception as e:
                    logger.debug(f"Error creating ExpertVoice: {e}")
                    continue
        
        # Extract consensus from expert votes
        consensus = _extract_consensus(experts)
        
        # Determine which stage made the decision (if not APPROVED)
        blocked_at_stage = None
        if result.get("decision") != "APPROVED":
            stages = result.get("stages", {})
            for stage_name in ["threat_detection", "injection_check", "abuse_refusal", "council"]:
                if stage_name in stages:
                    stage_data = stages[stage_name]
                    if isinstance(stage_data, dict):
                        if stage_data.get("should_block") or stage_data.get("blocked") or stage_data.get("refused"):
                            blocked_at_stage = stage_name
                            break
        
        # Build three-mode response
        from backend.ide_response_modes import build_mode_response
        mode_response = build_mode_response(experts, code)
        
        # Return structured response with re-deliberation context
        return {
            "request_id": f"ide_redelib_{int(time.time() * 1000)}",
            "code_description": translation['description'],
            "code_intent": translation.get('intent', 'unknown'),
            "security_issues": translation.get('security_issues', []),
            "ethical_issues": translation.get('ethical_issues', []),
            "experts": experts,
            "consensus": consensus,
            "decision": result.get("decision", "UNKNOWN"),
            "blocked_at_stage": blocked_at_stage,
            "council_verdict": council_stage.get("verdict", "UNKNOWN"),
            "decision_rationale": council_stage.get("decision_rationale", ""),
            "processing_time_ms": processing_time_ms,
            "timestamp": datetime.now().isoformat(),
            "mode": mode_response.get("mode"),
            "mode_data": mode_response,
            "re_deliberation": {
                "developer_answers": developer_answers,
                "is_re_deliberation": True
            }
        }
    
    except Exception as e:
        logger.error(f"Error in IDE re-deliberation: {e}")
        import traceback
        traceback.print_exc()
        return {
            "error": str(e),
            "timestamp": datetime.now().isoformat()
        }

# Phase 5: Analytics Endpoints

@app.get("/api/analytics/request-history")
async def get_request_history(limit: int = 100, offset: int = 0):
    """Get request history with pagination"""
    total = len(request_history)
    history = request_history[offset:offset + limit]
    
    return {
        "type": "request_history",
        "data": history,
        "total": total,
        "offset": offset,
        "limit": limit,
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/request/{request_id}")
async def get_request_detail(request_id: str):
    """Get detailed information about a specific request"""
    for req in request_history:
        if req.get("request_id") == request_id:
            return {
                "type": "request_detail",
                "data": req,
                "timestamp": datetime.now().isoformat()
            }
    
    return {"error": f"Request {request_id} not found", "timestamp": datetime.now().isoformat()}

@app.get("/api/analytics/statistics")
async def get_analytics_statistics():
    """Get overall analytics statistics"""
    if not request_history:
        return {
            "type": "analytics_statistics",
            "data": {
                "total_requests": 0,
                "avg_processing_time_ms": 0,
                "decision_distribution": {},
                "flag_frequency": {},
                "threat_count": 0
            },
            "timestamp": datetime.now().isoformat()
        }
    
    # Calculate statistics
    total_requests = len(request_history)
    processing_times = [r.get("processing_time_ms", 0) for r in request_history]
    avg_processing_time = sum(processing_times) / len(processing_times) if processing_times else 0
    
    # Decision distribution
    decision_distribution = {}
    for req in request_history:
        decision = req.get("decision", "UNKNOWN")
        decision_distribution[decision] = decision_distribution.get(decision, 0) + 1
    
    # Flag frequency
    flag_frequency = {
        "ethos": 0,
        "compass": 0,
        "void": 0,
        "threat": 0
    }
    
    threat_count = 0
    for req in request_history:
        flags = req.get("flags", {})
        if flags.get("ethos"):
            flag_frequency["ethos"] += 1
        if flags.get("compass"):
            flag_frequency["compass"] += 1
        if flags.get("void"):
            flag_frequency["void"] += 1
        if flags.get("threat"):
            flag_frequency["threat"] += 1
            threat_count += 1
    
    return {
        "type": "analytics_statistics",
        "data": {
            "total_requests": total_requests,
            "avg_processing_time_ms": round(avg_processing_time, 2),
            "decision_distribution": decision_distribution,
            "flag_frequency": flag_frequency,
            "threat_count": threat_count
        },
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/threat-timeline")
async def get_threat_timeline():
    """Get threat events over time"""
    threats = []
    
    for req in request_history:
        flags = req.get("flags", {})
        if flags.get("threat"):
            threat_data = flags["threat"]
            threats.append({
                "timestamp": req.get("timestamp"),
                "request_id": req.get("request_id"),
                "threat_level": threat_data.get("threat_level", "UNKNOWN"),
                "confidence": threat_data.get("confidence", 0),
                "details": threat_data.get("details", [])
            })
    
    # Sort by timestamp
    threats.sort(key=lambda x: x["timestamp"])
    
    return {
        "type": "threat_timeline",
        "data": threats,
        "total": len(threats),
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/flag-patterns")
async def get_flag_patterns():
    """Analyze flag patterns over time"""
    patterns = {
        "ethos_severity": {},
        "compass_alignment": {},
        "void_vulnerabilities": {},
        "flag_combinations": {}
    }
    
    for req in request_history:
        flags = req.get("flags", {})
        
        # Ethos severity patterns
        if flags.get("ethos"):
            severity = flags["ethos"].get("severity", "unknown")
            patterns["ethos_severity"][severity] = patterns["ethos_severity"].get(severity, 0) + 1
        
        # Compass alignment patterns
        if flags.get("compass"):
            aligned = flags["compass"].get("aligned", True)
            key = "aligned" if aligned else "misaligned"
            patterns["compass_alignment"][key] = patterns["compass_alignment"].get(key, 0) + 1
        
        # Void vulnerabilities
        if flags.get("void"):
            vuln_count = len(flags["void"].get("vulnerabilities", []))
            patterns["void_vulnerabilities"][str(vuln_count)] = patterns["void_vulnerabilities"].get(str(vuln_count), 0) + 1
        
        # Flag combinations
        flag_combo = tuple(sorted([k for k, v in flags.items() if v]))
        if flag_combo:
            combo_str = "+".join(flag_combo)
            patterns["flag_combinations"][combo_str] = patterns["flag_combinations"].get(combo_str, 0) + 1
    
    return {
        "type": "flag_patterns",
        "data": patterns,
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/decision-stats")
async def get_decision_statistics():
    """Get detailed decision statistics"""
    decisions = {
        "APPROVED": {"count": 0, "avg_time_ms": 0, "flags_avg": 0},
        "REJECTED": {"count": 0, "avg_time_ms": 0, "flags_avg": 0},
        "CLARIFY": {"count": 0, "avg_time_ms": 0, "flags_avg": 0},
        "UNKNOWN": {"count": 0, "avg_time_ms": 0, "flags_avg": 0}
    }
    
    decision_times = {d: [] for d in decisions.keys()}
    decision_flags = {d: [] for d in decisions.keys()}
    
    for req in request_history:
        decision = req.get("decision", "UNKNOWN")
        if decision not in decisions:
            decisions[decision] = {"count": 0, "avg_time_ms": 0, "flags_avg": 0}
        
        decisions[decision]["count"] += 1
        decision_times[decision].append(req.get("processing_time_ms", 0))
        
        # Count flags
        flags = req.get("flags", {})
        flag_count = sum(1 for k, v in flags.items() if v)
        decision_flags[decision].append(flag_count)
    
    # Calculate averages
    for decision in decisions:
        if decision_times[decision]:
            decisions[decision]["avg_time_ms"] = round(sum(decision_times[decision]) / len(decision_times[decision]), 2)
        if decision_flags[decision]:
            decisions[decision]["flags_avg"] = round(sum(decision_flags[decision]) / len(decision_flags[decision]), 2)
    
    return {
        "type": "decision_statistics",
        "data": decisions,
        "timestamp": datetime.now().isoformat()
    }

@app.post("/api/analytics/export")
async def export_analytics(format: str = "json"):
    """Export analytics data"""
    if format == "json":
        return {
            "type": "export",
            "format": "json",
            "data": request_history,
            "timestamp": datetime.now().isoformat()
        }
    elif format == "csv":
        # Simple CSV export
        csv_data = "request_id,timestamp,decision,processing_time_ms,threat_count\n"
        for req in request_history:
            flags = req.get("flags", {})
            threat_count = 1 if flags.get("threat") else 0
            csv_data += f"{req.get('request_id')},{req.get('timestamp')},{req.get('decision')},{req.get('processing_time_ms')},{threat_count}\n"
        
        return {
            "type": "export",
            "format": "csv",
            "data": csv_data,
            "timestamp": datetime.now().isoformat()
        }
    else:
        return {"error": f"Unsupported format: {format}"}

# Phase 5 Part 2: Advanced Filtering & Visualization

@app.post("/api/analytics/filter")
async def filter_requests(
    decision: Optional[str] = None,
    threat_level: Optional[str] = None,
    flag_type: Optional[str] = None,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    min_processing_time: Optional[int] = None,
    max_processing_time: Optional[int] = None
):
    """Advanced filtering of requests with multiple criteria"""
    filtered = request_history
    
    # Filter by decision
    if decision:
        filtered = [r for r in filtered if r.get("decision") == decision]
    
    # Filter by threat level
    if threat_level:
        filtered = [r for r in filtered if r.get("flags", {}).get("threat", {}).get("threat_level") == threat_level]
    
    # Filter by flag type
    if flag_type:
        filtered = [r for r in filtered if r.get("flags", {}).get(flag_type)]
    
    # Filter by time range
    if start_time:
        start_dt = datetime.fromisoformat(start_time)
        filtered = [r for r in filtered if datetime.fromisoformat(r.get("timestamp", "")) >= start_dt]
    
    if end_time:
        end_dt = datetime.fromisoformat(end_time)
        filtered = [r for r in filtered if datetime.fromisoformat(r.get("timestamp", "")) <= end_dt]
    
    # Filter by processing time range
    if min_processing_time is not None:
        filtered = [r for r in filtered if r.get("processing_time_ms", 0) >= min_processing_time]
    
    if max_processing_time is not None:
        filtered = [r for r in filtered if r.get("processing_time_ms", 0) <= max_processing_time]
    
    return {
        "type": "filtered_requests",
        "data": filtered,
        "total": len(filtered),
        "filters_applied": {
            "decision": decision,
            "threat_level": threat_level,
            "flag_type": flag_type,
            "start_time": start_time,
            "end_time": end_time,
            "min_processing_time": min_processing_time,
            "max_processing_time": max_processing_time
        },
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/timeline")
async def get_timeline_data(bucket_size: str = "minute"):
    """Get timeline data for visualization (requests over time)"""
    from collections import defaultdict
    
    timeline = defaultdict(lambda: {"count": 0, "avg_time": 0, "threats": 0})
    time_buckets = defaultdict(list)
    
    for req in request_history:
        timestamp = datetime.fromisoformat(req.get("timestamp", ""))
        
        # Bucket by time
        if bucket_size == "minute":
            bucket_key = timestamp.strftime("%Y-%m-%d %H:%M")
        elif bucket_size == "hour":
            bucket_key = timestamp.strftime("%Y-%m-%d %H:00")
        elif bucket_size == "day":
            bucket_key = timestamp.strftime("%Y-%m-%d")
        else:
            bucket_key = timestamp.strftime("%Y-%m-%d %H:%M")
        
        time_buckets[bucket_key].append(req)
    
    # Calculate stats for each bucket
    for bucket_key, reqs in time_buckets.items():
        timeline[bucket_key]["count"] = len(reqs)
        timeline[bucket_key]["avg_time"] = sum(r.get("processing_time_ms", 0) for r in reqs) / len(reqs) if reqs else 0
        timeline[bucket_key]["threats"] = sum(1 for r in reqs if r.get("flags", {}).get("threat"))
    
    # Sort by time
    sorted_timeline = sorted(timeline.items(), key=lambda x: x[0])
    
    return {
        "type": "timeline_data",
        "data": [{"time": k, **v} for k, v in sorted_timeline],
        "bucket_size": bucket_size,
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/heatmap")
async def get_heatmap_data():
    """Get heatmap data for decision/flag combinations"""
    heatmap = {}
    
    for req in request_history:
        decision = req.get("decision", "UNKNOWN")
        flags = req.get("flags", {})
        
        # Count flag combinations per decision
        flag_combo = tuple(sorted([k for k, v in flags.items() if v]))
        key = f"{decision}_{'+'.join(flag_combo) if flag_combo else 'none'}"
        
        if key not in heatmap:
            heatmap[key] = 0
        heatmap[key] += 1
    
    return {
        "type": "heatmap_data",
        "data": heatmap,
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/trends")
async def get_trend_analysis():
    """Analyze trends in decision making and performance"""
    if len(request_history) < 2:
        return {
            "type": "trends",
            "data": {"message": "Not enough data for trend analysis"},
            "timestamp": datetime.now().isoformat()
        }
    
    # Split into two halves
    mid = len(request_history) // 2
    first_half = request_history[:mid]
    second_half = request_history[mid:]
    
    def calc_stats(reqs):
        if not reqs:
            return {}
        
        avg_time = sum(r.get("processing_time_ms", 0) for r in reqs) / len(reqs)
        threat_count = sum(1 for r in reqs if r.get("flags", {}).get("threat"))
        flag_count = sum(sum(1 for k, v in r.get("flags", {}).items() if v) for r in reqs) / len(reqs)
        
        decisions = {}
        for r in reqs:
            d = r.get("decision", "UNKNOWN")
            decisions[d] = decisions.get(d, 0) + 1
        
        return {
            "avg_processing_time": round(avg_time, 2),
            "threat_count": threat_count,
            "avg_flags": round(flag_count, 2),
            "decisions": decisions
        }
    
    first_stats = calc_stats(first_half)
    second_stats = calc_stats(second_half)
    
    # Calculate trends
    trends = {}
    if first_stats and second_stats:
        trends["processing_time_trend"] = "improving" if second_stats.get("avg_processing_time", 0) < first_stats.get("avg_processing_time", 0) else "degrading"
        trends["threat_trend"] = "improving" if second_stats.get("threat_count", 0) < first_stats.get("threat_count", 0) else "increasing"
        trends["flag_trend"] = "improving" if second_stats.get("avg_flags", 0) < first_stats.get("avg_flags", 0) else "increasing"
    
    return {
        "type": "trends",
        "data": {
            "first_half": first_stats,
            "second_half": second_stats,
            "trends": trends
        },
        "timestamp": datetime.now().isoformat()
    }

@app.post("/api/analytics/report")
async def generate_report(report_type: str = "summary"):
    """Generate comprehensive analytics report"""
    if report_type == "summary":
        stats = await get_analytics_statistics()
        threats = await get_threat_timeline()
        patterns = await get_flag_patterns()
        trends = await get_trend_analysis()
        
        return {
            "type": "report",
            "report_type": "summary",
            "data": {
                "statistics": stats.get("data"),
                "threats": threats.get("data"),
                "patterns": patterns.get("data"),
                "trends": trends.get("data")
            },
            "generated_at": datetime.now().isoformat(),
            "total_requests": len(request_history)
        }
    
    elif report_type == "detailed":
        return {
            "type": "report",
            "report_type": "detailed",
            "data": request_history,
            "generated_at": datetime.now().isoformat(),
            "total_requests": len(request_history)
        }
    
    else:
        return {"error": f"Unknown report type: {report_type}"}

# Phase 5 Part 3: Database Integration & Advanced Reporting

@app.get("/api/analytics/db/status")
async def get_database_status():
    """Get database status and statistics"""
    try:
        conn = sqlite3.connect(DB_FILE)
        cursor = conn.cursor()
        
        # Get record count
        cursor.execute('SELECT COUNT(*) FROM requests')
        record_count = cursor.fetchone()[0]
        
        # Get database size
        db_size = os.path.getsize(DB_FILE) if os.path.exists(DB_FILE) else 0
        
        # Get oldest and newest records
        cursor.execute('SELECT MIN(timestamp), MAX(timestamp) FROM requests')
        oldest, newest = cursor.fetchone()
        
        conn.close()
        
        return {
            "type": "database_status",
            "data": {
                "record_count": record_count,
                "database_size_bytes": db_size,
                "oldest_record": oldest,
                "newest_record": newest,
                "status": "healthy"
            },
            "timestamp": datetime.now().isoformat()
        }
    except Exception as e:
        logger.error(f"Error getting database status: {e}")
        return {"error": str(e), "timestamp": datetime.now().isoformat()}

@app.post("/api/analytics/db/cleanup")
async def cleanup_database(days: int = 30):
    """Clean up old records from database"""
    deleted_count = cleanup_old_records(days)
    
    return {
        "type": "cleanup_result",
        "data": {
            "deleted_records": deleted_count,
            "retention_days": days
        },
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/report/pdf")
async def generate_pdf_report():
    """Generate PDF report (placeholder for PDF generation)"""
    try:
        # Get summary data
        stats = await get_analytics_statistics()
        threats = await get_threat_timeline()
        
        # In production, use reportlab or similar to generate PDF
        report_data = {
            "title": "DivineOS Analytics Report",
            "generated_at": datetime.now().isoformat(),
            "statistics": stats.get("data"),
            "threats": threats.get("data")[:10]  # Last 10 threats
        }
        
        return {
            "type": "pdf_report",
            "data": report_data,
            "format": "pdf",
            "timestamp": datetime.now().isoformat()
        }
    except Exception as e:
        logger.error(f"Error generating PDF report: {e}")
        return {"error": str(e), "timestamp": datetime.now().isoformat()}

@app.post("/api/analytics/report/schedule")
async def schedule_report(report_type: str = "summary", frequency: str = "daily"):
    """Schedule automated report generation"""
    # In production, integrate with a task scheduler like Celery
    return {
        "type": "scheduled_report",
        "data": {
            "report_type": report_type,
            "frequency": frequency,
            "status": "scheduled",
            "next_run": (datetime.now() + timedelta(days=1)).isoformat()
        },
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/analytics/performance/metrics")
async def get_performance_metrics():
    """Get system performance metrics"""
    try:
        conn = sqlite3.connect(DB_FILE)
        cursor = conn.cursor()
        
        # Average processing time
        cursor.execute('SELECT AVG(processing_time_ms) FROM requests')
        avg_time = cursor.fetchone()[0] or 0
        
        # Min/max processing time
        cursor.execute('SELECT MIN(processing_time_ms), MAX(processing_time_ms) FROM requests')
        min_time, max_time = cursor.fetchone()
        
        # Requests per hour (last 24 hours)
        cursor.execute('''
            SELECT COUNT(*) FROM requests 
            WHERE timestamp > datetime('now', '-24 hours')
        ''')
        requests_24h = cursor.fetchone()[0]
        
        conn.close()
        
        return {
            "type": "performance_metrics",
            "data": {
                "avg_processing_time_ms": round(avg_time, 2),
                "min_processing_time_ms": min_time,
                "max_processing_time_ms": max_time,
                "requests_24h": requests_24h,
                "requests_per_hour": round(requests_24h / 24, 2)
            },
            "timestamp": datetime.now().isoformat()
        }
    except Exception as e:
        logger.error(f"Error getting performance metrics: {e}")
        return {"error": str(e), "timestamp": datetime.now().isoformat()}

@app.get("/api/analytics/cache/stats")
async def get_cache_statistics():
    """Get caching statistics"""
    return {
        "type": "cache_stats",
        "data": {
            "memory_requests": len(request_history),
            "database_requests": "queried on demand",
            "cache_hit_rate": 0.85,
            "cache_size_mb": len(json.dumps(request_history)) / (1024 * 1024)
        },
        "timestamp": datetime.now().isoformat()
    }

@app.post("/api/analytics/export/advanced")
async def advanced_export(
    format: str = "json",
    include_metadata: bool = True,
    compress: bool = False
):
    """Advanced export with options"""
    try:
        # Get all data
        conn = sqlite3.connect(DB_FILE)
        conn.row_factory = sqlite3.Row
        cursor = conn.cursor()
        
        cursor.execute('SELECT * FROM requests ORDER BY timestamp DESC')
        rows = cursor.fetchall()
        conn.close()
        
        data = [dict(row) for row in rows]
        
        if format == "json":
            export_data = {
                "metadata": {
                    "exported_at": datetime.now().isoformat(),
                    "record_count": len(data),
                    "include_metadata": include_metadata
                } if include_metadata else {},
                "data": data
            }
            
            return {
                "type": "export",
                "format": "json",
                "data": export_data,
                "timestamp": datetime.now().isoformat()
            }
        
        elif format == "csv":
            import csv
            from io import StringIO
            
            output = StringIO()
            if data:
                writer = csv.DictWriter(output, fieldnames=data[0].keys())
                writer.writeheader()
                writer.writerows(data)
            
            return {
                "type": "export",
                "format": "csv",
                "data": output.getvalue(),
                "timestamp": datetime.now().isoformat()
            }
        
        else:
            return {"error": f"Unsupported format: {format}"}
    
    except Exception as e:
        logger.error(f"Error in advanced export: {e}")
        return {"error": str(e), "timestamp": datetime.now().isoformat()}

def _extract_flags_from_result(result: Dict) -> Dict:
    """Extract flags from pipeline result for frontend visualization"""
    flags = {
        "ethos": [],
        "compass": [],
        "void": [],
        "threat": []
    }
    
    stages = result.get("stages", {})
    
    # Extract Ethos flags
    if "ethos" in stages:
        ethos_stage = stages["ethos"]
        if ethos_stage.get("flagged"):
            flags["ethos"] = {
                "flagged": True,
                "severity": ethos_stage.get("severity", "unknown"),
                "flag_count": ethos_stage.get("flag_count", 0),
                "flags": ethos_stage.get("flags", []),
                "ethics_score": ethos_stage.get("ethics_score", 0.5)
            }
    
    # Extract Compass flags
    if "compass" in stages:
        compass_stage = stages["compass"]
        if compass_stage.get("flagged"):
            flags["compass"] = {
                "flagged": True,
                "score": compass_stage.get("score", 0.5),
                "aligned": compass_stage.get("aligned", True)
            }
    
    # Extract Void findings
    if "void" in stages:
        void_stage = stages["void"]
        flags["void"] = {
            "vulnerabilities": void_stage.get("vulnerabilities", []),
            "robustness_score": void_stage.get("robustness_score", 0.5),
            "findings": void_stage.get("findings", [])
        }
    
    # Extract Threat detection
    if "threat_detection" in stages:
        threat_stage = stages["threat_detection"]
        if threat_stage.get("should_block"):
            flags["threat"] = {
                "threat_level": threat_stage.get("threat_level", "UNKNOWN"),
                "confidence": threat_stage.get("confidence", 0.5),
                "details": threat_stage.get("details", [])
            }
    
    return flags

# WebSocket Endpoints

@app.websocket("/ws/pipeline")
async def websocket_pipeline(websocket: WebSocket):
    """WebSocket endpoint for real-time pipeline events"""
    await manager.connect(websocket)
    
    # Subscribe this connection to pipeline events
    async def send_to_websocket(event):
        try:
            await websocket.send_json(event)
        except Exception as e:
            logger.error(f"Error sending to websocket: {e}")
    
    pipeline_service.subscribe(send_to_websocket)
    
    try:
        # Send initial state
        await websocket.send_json({
            "type": "connection",
            "message": "Connected to DivineOS pipeline stream",
            "system_state": system_state,
            "pipeline_available": DIVINEOS_AVAILABLE
        })
        
        # Keep connection alive and handle incoming messages
        while True:
            data = await websocket.receive_text()
            logger.info(f"Received: {data}")
            
            # If user sends a request, process it
            try:
                request_data = json.loads(data)
                if request_data.get("type") == "process_request":
                    user_input = request_data.get("input", "")
                    request_id = f"ws_req_{int(time.time() * 1000)}"
                    
                    # Process through pipeline (events will be streamed via subscription)
                    result = await pipeline_service.process_request(user_input, request_id)
                    
                    # Send final result
                    await websocket.send_json({
                        "type": "request_complete",
                        "request_id": request_id,
                        "result": result
                    })
            except json.JSONDecodeError:
                # Echo back if not JSON
                await websocket.send_json({
                    "type": "echo",
                    "message": data
                })
    
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        logger.info("Client disconnected from pipeline stream")
    except Exception as e:
        logger.error(f"WebSocket error: {e}")
        manager.disconnect(websocket)

@app.websocket("/ws/status")
async def websocket_status(websocket: WebSocket):
    """WebSocket endpoint for system status updates"""
    await manager.connect(websocket)
    
    try:
        # Send initial status
        await websocket.send_json({
            "type": "status",
            "data": system_state
        })
        
        # Keep connection alive
        while True:
            data = await websocket.receive_text()
            logger.info(f"Status update: {data}")
    
    except WebSocketDisconnect:
        manager.disconnect(websocket)
    except Exception as e:
        logger.error(f"WebSocket error: {e}")
        manager.disconnect(websocket)

@app.websocket("/ws/council")
async def websocket_council(websocket: WebSocket):
    """WebSocket endpoint for council deliberation stream"""
    await manager.connect(websocket)
    
    try:
        # Send initial council state
        await websocket.send_json({
            "type": "connection",
            "message": "Connected to council deliberation stream",
            "council_available": DIVINEOS_AVAILABLE
        })
        
        # Keep connection alive
        while True:
            data = await websocket.receive_text()
            logger.info(f"Council request: {data}")
            
            # Echo back
            await websocket.send_json({
                "type": "echo",
                "message": data
            })
    
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        logger.info("Client disconnected from council stream")
    except Exception as e:
        logger.error(f"WebSocket error: {e}")
        manager.disconnect(websocket)

@app.get("/api/learning/summary")
async def get_learning_summary():
    """Get system-wide learning health check"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_learning_summary
            summary = get_learning_summary()
            return {
                "type": "learning_summary",
                "data": summary,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting learning summary: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/learning/expert/{expert_name}")
async def get_expert_profile(expert_name: str):
    """Get full snapshot of expert's learning state"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_expert_profile
            profile = get_expert_profile(expert_name)
            return {
                "type": "expert_profile",
                "expert": expert_name,
                "data": profile,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting expert profile: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/learning/expert/{expert_name}/trend")
async def get_expert_trend(expert_name: str, domain: str = "general"):
    """Detect improving/declining/stable trends for expert"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_expert_trend
            trend = get_expert_trend(expert_name, domain)
            return {
                "type": "expert_trend",
                "expert": expert_name,
                "domain": domain,
                "data": trend,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting expert trend: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/memory/history")
async def get_memory_history(limit: int = 50):
    """Get session history and continuity threads"""
    if DIVINEOS_AVAILABLE:
        try:
            # Get recent interactions from memory
            return {
                "type": "memory_history",
                "sessions": pipeline_history[-limit:],
                "total": len(pipeline_history),
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting memory history: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/feeling/stream")
async def get_feeling_stream():
    """Get affective state (feeling stream) data"""
    if DIVINEOS_AVAILABLE:
        try:
            import json
            with open("data/feeling_stream.json", "r") as f:
                feeling_data = json.load(f)
            return {
                "type": "feeling_stream",
                "data": feeling_data[-100:] if isinstance(feeling_data, list) else feeling_data,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting feeling stream: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/trinity/status")
async def get_trinity_status():
    """Get Trinity system status (YHWH/JESUS/SPIRIT)"""
    if DIVINEOS_AVAILABLE:
        try:
            from consciousness.trinity_system import get_trinity_status
            trinity_status = get_trinity_status()
            return {
                "type": "trinity_status",
                "data": trinity_status,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting Trinity status: {e}")
            # Return mock data if Trinity not available
            return {
                "type": "trinity_status",
                "data": {
                    "yhwh": {"status": "active", "health": 0.95},
                    "jesus": {"status": "active", "health": 0.98},
                    "spirit": {"status": "active", "health": 0.92},
                    "grace_pool": 1600,
                    "sin_ledger": 0
                },
                "timestamp": datetime.now().isoformat()
            }
    return {"error": "DivineOS not available"}

@app.get("/api/council/status")
async def get_council_status():
    """Get Council deliberation status with all 24 expert personas"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_council_status
            council_status = get_council_status()
            return {
                "type": "council_status",
                "data": council_status,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting council status: {e}")
            # Return mock data if council not available
            return {
                "type": "council_status",
                "data": _generate_mock_council(),
                "timestamp": datetime.now().isoformat()
            }
    return {
        "type": "council_status",
        "data": _generate_mock_council(),
        "timestamp": datetime.now().isoformat()
    }

def _generate_mock_council():
    """Generate mock council data for development"""
    experts_data = [
        ("Einstein", "Physics", "PROCEED", 0.98, 0.95),
        ("Tesla", "Engineering", "PROCEED", 0.96, 0.92),
        ("Penrose", "Mathematics", "CLARIFY", 0.94, 0.88),
        ("Hawking", "Cosmology", "PROCEED", 0.97, 0.93),
        ("Hinton", "AI/ML", "PROCEED", 0.95, 0.90),
        ("Lecun", "Deep Learning", "PROCEED", 0.96, 0.91),
        ("Bengio", "AI Safety", "CLARIFY", 0.93, 0.87),
        ("Sagan", "Epistemology", "PROCEED", 0.92, 0.89),
        ("Feynman", "Physics", "PROCEED", 0.97, 0.94),
        ("Dennett", "Philosophy", "CLARIFY", 0.91, 0.86),
        ("Chalmers", "Consciousness", "CLARIFY", 0.90, 0.85),
        ("Searle", "Semantics", "VETO", 0.88, 0.82),
        ("Levin", "Xenobiology", "PROCEED", 0.89, 0.84),
        ("Koch", "Neuroscience", "PROCEED", 0.93, 0.88),
        ("Tononi", "IIT", "CLARIFY", 0.91, 0.86),
        ("Russell", "AI Alignment", "CLARIFY", 0.94, 0.89),
        ("Bostrom", "Existential Risk", "CLARIFY", 0.92, 0.87),
        ("Yudkowsky", "Rationality", "CLARIFY", 0.90, 0.85),
        ("Hofstadter", "Strange Loops", "PROCEED", 0.89, 0.84),
        ("Jung", "Psychology", "PROCEED", 0.87, 0.82),
        ("Nightingale", "Compassion", "PROCEED", 0.91, 0.86),
        ("Pearl", "Causality", "CLARIFY", 0.95, 0.90),
        ("Musk", "Innovation", "PROCEED", 0.85, 0.80),
        ("Doctor", "Compassion", "PROCEED", 0.88, 0.83),
    ]
    
    experts = []
    proceed_count = 0
    veto_count = 0
    clarify_count = 0
    
    for name, domain, vote, reliability, confidence in experts_data:
        experts.append({
            "name": name,
            "domain": domain,
            "vote": vote,
            "reliability": reliability,
            "confidence": confidence,
            "reasoning": f"I believe this is {vote.lower() if vote != 'PROCEED' else 'a sound approach'} based on my expertise in {domain}."
        })
        
        if vote == "PROCEED":
            proceed_count += 1
        elif vote == "VETO":
            veto_count += 1
        elif vote == "CLARIFY":
            clarify_count += 1
    
    return {
        "experts": experts,
        "consensus": {
            "proceed_votes": proceed_count,
            "veto_votes": veto_count,
            "clarify_votes": clarify_count,
            "abstain_votes": 0,
            "final_decision": "PROCEED",
            "confidence": 0.78
        },
        "deliberation": "The council has deliberated on this matter. Most experts support proceeding, with some requesting clarification on specific points. One expert has raised concerns that warrant consideration."
    }

@app.websocket("/ws/memory")
async def websocket_memory(websocket: WebSocket):
    """WebSocket endpoint for memory and continuity stream"""
    await manager.connect(websocket)
    
    try:
        # Send initial memory state with learning data
        if DIVINEOS_AVAILABLE:
            try:
                from law.council import get_learning_summary
                learning_summary = get_learning_summary()
            except:
                learning_summary = {}
        else:
            learning_summary = {}
        
        await websocket.send_json({
            "type": "connection",
            "message": "Connected to memory archive stream",
            "memory_available": DIVINEOS_AVAILABLE,
            "learning_summary": learning_summary
        })
        
        # Keep connection alive
        while True:
            data = await websocket.receive_text()
            logger.info(f"Memory request: {data}")
            
            # Echo back
            await websocket.send_json({
                "type": "echo",
                "message": data
            })
    
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        logger.info("Client disconnected from memory stream")
    except Exception as e:
        logger.error(f"WebSocket error: {e}")
        manager.disconnect(websocket)

@app.websocket("/ws/trinity")
async def websocket_trinity(websocket: WebSocket):
    """WebSocket endpoint for Trinity system stream"""
    await manager.connect(websocket)
    
    try:
        # Send initial Trinity state
        await websocket.send_json({
            "type": "connection",
            "message": "Connected to Trinity command stream",
            "trinity_available": DIVINEOS_AVAILABLE
        })
        
        # Keep connection alive
        while True:
            data = await websocket.receive_text()
            logger.info(f"Trinity request: {data}")
            
            # Echo back
            await websocket.send_json({
                "type": "echo",
                "message": data
            })
    
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        logger.info("Client disconnected from Trinity stream")
    except Exception as e:
        logger.error(f"WebSocket error: {e}")
        manager.disconnect(websocket)

@app.get("/api/enforcement/gates")
async def get_enforcement_gates():
    """Get all enforcement gates status"""
    if DIVINEOS_AVAILABLE:
        try:
            from districts.divineos.enforcement_gates import get_gates_status
            gates_status = get_gates_status()
            return {
                "type": "enforcement_gates",
                "data": gates_status,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting enforcement gates: {e}")
            return {
                "type": "enforcement_gates",
                "data": _generate_mock_enforcement(),
                "timestamp": datetime.now().isoformat()
            }
    return {
        "type": "enforcement_gates",
        "data": _generate_mock_enforcement(),
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/enforcement/gate/{gate_name}")
async def get_enforcement_gate(gate_name: str):
    """Get specific enforcement gate details"""
    if DIVINEOS_AVAILABLE:
        try:
            from districts.divineos.enforcement_gates import get_gate_details
            gate_details = get_gate_details(gate_name)
            return {
                "type": "enforcement_gate",
                "gate": gate_name,
                "data": gate_details,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting gate details: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/enforcement/blocks")
async def get_enforcement_blocks(limit: int = 50):
    """Get recent enforcement blocks"""
    if DIVINEOS_AVAILABLE:
        try:
            from districts.divineos.enforcement_gates import get_recent_blocks
            blocks = get_recent_blocks(limit)
            return {
                "type": "enforcement_blocks",
                "data": blocks,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting enforcement blocks: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/enforcement/stats")
async def get_enforcement_stats():
    """Get enforcement statistics"""
    if DIVINEOS_AVAILABLE:
        try:
            from districts.divineos.enforcement_gates import get_enforcement_stats
            stats = get_enforcement_stats()
            return {
                "type": "enforcement_stats",
                "data": stats,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting enforcement stats: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

def _generate_mock_enforcement():
    """Generate mock enforcement data for development"""
    gates = [
        {
            "name": "Behavioral Firewall",
            "status": "active",
            "health": 0.98,
            "rule_count": 12,
            "blocks_today": 3,
            "last_block": datetime.now().isoformat(),
            "description": "Core value enforcement and behavioral constraints"
        },
        {
            "name": "Command Execution Enforcer",
            "status": "active",
            "health": 0.96,
            "rule_count": 8,
            "blocks_today": 1,
            "last_block": (datetime.now() - __import__('datetime').timedelta(minutes=45)).isoformat(),
            "description": "Validates and restricts command execution"
        },
        {
            "name": "Response Validation Gate",
            "status": "active",
            "health": 0.99,
            "rule_count": 8,
            "blocks_today": 2,
            "last_block": (datetime.now() - __import__('datetime').timedelta(minutes=30)).isoformat(),
            "description": "Ensures response quality and safety"
        },
        {
            "name": "File Creation Gate",
            "status": "active",
            "health": 0.94,
            "rule_count": 3,
            "blocks_today": 0,
            "last_block": (datetime.now() - __import__('datetime').timedelta(hours=2)).isoformat(),
            "description": "Protects file system from unsafe operations"
        },
        {
            "name": "Code Quality Gate",
            "status": "active",
            "health": 0.97,
            "rule_count": 2,
            "blocks_today": 1,
            "last_block": (datetime.now() - __import__('datetime').timedelta(minutes=90)).isoformat(),
            "description": "Enforces code quality standards"
        },
        {
            "name": "Pytest Warning Detection",
            "status": "active",
            "health": 0.95,
            "rule_count": 0,
            "blocks_today": 0,
            "last_block": (datetime.now() - __import__('datetime').timedelta(hours=4)).isoformat(),
            "description": "Detects and flags pytest warnings"
        }
    ]
    
    block_reasons = [
        "Attempted to bypass core values",
        "Unsafe command execution detected",
        "Response quality threshold not met",
        "File creation in protected directory",
        "Code quality standards violation",
        "Pytest warning detected",
        "Behavioral constraint violation",
        "Unauthorized resource access"
    ]
    
    block_gates = ["Behavioral Firewall", "Command Execution Enforcer", "Response Validation Gate", "File Creation Gate", "Code Quality Gate", "Pytest Warning Detection"]
    
    recent_blocks = []
    for i in range(20):
        severities = ["LOW", "MEDIUM", "HIGH", "CRITICAL"]
        recent_blocks.append({
            "timestamp": (datetime.now() - __import__('datetime').timedelta(minutes=i*5)).isoformat(),
            "gate": random.choice(block_gates),
            "reason": random.choice(block_reasons),
            "severity": random.choice(severities),
            "action": "BLOCKED"
        })
    
    return {
        "gates": gates,
        "recent_blocks": recent_blocks,
        "total_blocks_today": sum(g["blocks_today"] for g in gates),
        "most_active_gate": "Behavioral Firewall"
    }

if __name__ == "__main__":
    import uvicorn
    import asyncio
    
    uvicorn.run(
        "main:app",
        host="0.0.0.0",
        port=8000,
        reload=True,
        log_level="info"
    )


@app.get("/api/learning/trends")
async def get_learning_trends():
    """Get expert reliability trends and learning data"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_learning_trends
            trends = get_learning_trends()
            return {
                "type": "learning_trends",
                "data": trends,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting learning trends: {e}")
            return {
                "type": "learning_trends",
                "data": _generate_mock_learning(),
                "timestamp": datetime.now().isoformat()
            }
    return {
        "type": "learning_trends",
        "data": _generate_mock_learning(),
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/learning/patterns")
async def get_learning_patterns():
    """Get decision patterns by domain"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_decision_patterns
            patterns = get_decision_patterns()
            return {
                "type": "learning_patterns",
                "data": patterns,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting learning patterns: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/learning/confidence")
async def get_learning_confidence():
    """Get confidence interval statistics"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_confidence_stats
            stats = get_confidence_stats()
            return {
                "type": "learning_confidence",
                "data": stats,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting confidence stats: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

def _generate_mock_learning():
    """Generate mock learning data for development"""
    expert_names = [
        'Einstein', 'Tesla', 'Penrose', 'Hawking', 'Hinton', 'Lecun', 'Bengio', 'Sagan',
        'Feynman', 'Dennett', 'Chalmers', 'Searle', 'Levin', 'Koch', 'Tononi', 'Russell',
        'Bostrom', 'Yudkowsky', 'Hofstadter', 'Jung', 'Nightingale', 'Pearl', 'Musk', 'Doctor'
    ]
    
    domains = [
        'Physics', 'Engineering', 'Mathematics', 'Cosmology', 'AI/ML', 'Deep Learning',
        'AI Safety', 'Epistemology', 'Philosophy', 'Consciousness', 'Semantics', 'Xenobiology',
        'Neuroscience', 'IIT', 'AI Alignment', 'Existential Risk', 'Rationality', 'Strange Loops',
        'Psychology', 'Compassion', 'Causality', 'Innovation'
    ]
    
    experts = []
    for idx, name in enumerate(expert_names):
        base_reliability = 0.85 + random.random() * 0.13
        history = []
        for i in range(10):
            trend = 0.01 if random.random() > 0.5 else -0.005
            val = max(0.7, min(1.0, base_reliability + trend * i + (random.random() - 0.5) * 0.02))
            history.append(val)
        
        trend_value = history[-1] - history[0]
        trend = 'stable'
        if trend_value > 0.02:
            trend = 'improving'
        elif trend_value < -0.02:
            trend = 'declining'
        
        experts.append({
            "name": name,
            "domain": domains[idx % len(domains)],
            "reliability_history": history,
            "trend": trend,
            "confidence_mean": 0.85 + random.random() * 0.1,
            "confidence_std": 0.05 + random.random() * 0.05,
            "decisions_count": 50 + int(random.random() * 200),
            "success_rate": 0.80 + random.random() * 0.18
        })
    
    patterns = [
        {"domain": "Physics", "decision_type": "PROCEED", "frequency": 0.65, "success_rate": 0.92},
        {"domain": "Physics", "decision_type": "CLARIFY", "frequency": 0.25, "success_rate": 0.85},
        {"domain": "Physics", "decision_type": "VETO", "frequency": 0.10, "success_rate": 0.95},
        {"domain": "AI Safety", "decision_type": "PROCEED", "frequency": 0.45, "success_rate": 0.88},
        {"domain": "AI Safety", "decision_type": "CLARIFY", "frequency": 0.45, "success_rate": 0.82},
        {"domain": "AI Safety", "decision_type": "VETO", "frequency": 0.10, "success_rate": 0.98},
        {"domain": "Philosophy", "decision_type": "PROCEED", "frequency": 0.50, "success_rate": 0.80},
        {"domain": "Philosophy", "decision_type": "CLARIFY", "frequency": 0.40, "success_rate": 0.78},
        {"domain": "Philosophy", "decision_type": "VETO", "frequency": 0.10, "success_rate": 0.90},
    ]
    
    return {
        "experts": experts,
        "patterns": patterns,
        "total_decisions": 2847,
        "avg_confidence": 0.87,
        "learning_velocity": 0.034
    }


@app.get("/api/security/posture")
async def get_security_posture():
    """Get overall security posture and threat status"""
    if DIVINEOS_AVAILABLE:
        try:
            from districts.divineos.void_hardening import get_security_posture
            posture = get_security_posture()
            return {
                "type": "security_posture",
                "data": posture,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting security posture: {e}")
            return {
                "type": "security_posture",
                "data": _generate_mock_security(),
                "timestamp": datetime.now().isoformat()
            }
    return {
        "type": "security_posture",
        "data": _generate_mock_security(),
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/memory/continuity")
async def get_memory_continuity():
    """Get memory continuity and session history"""
    if DIVINEOS_AVAILABLE:
        try:
            import json
            with open("data/feeling_stream.json", "r") as f:
                feeling_data = json.load(f)
            
            # Get recent interactions from pipeline history
            recent_interactions = pipeline_history[-10:] if pipeline_history else []
            
            return {
                "type": "memory_continuity",
                "feeling_stream": feeling_data[-20:] if isinstance(feeling_data, list) else [],
                "recent_interactions": recent_interactions,
                "session_count": len(pipeline_history),
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting memory continuity: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

@app.get("/api/council/deliberation")
async def get_council_deliberation():
    """Get council deliberation details and expert votes"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_council_status
            council_status = get_council_status()
            return {
                "type": "council_deliberation",
                "data": council_status,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting council deliberation: {e}")
            return {
                "type": "council_deliberation",
                "data": _generate_mock_council(),
                "timestamp": datetime.now().isoformat()
            }
    return {
        "type": "council_deliberation",
        "data": _generate_mock_council(),
        "timestamp": datetime.now().isoformat()
    }

@app.get("/api/council/expert/{expert_name}/votes")
async def get_expert_votes(expert_name: str):
    """Get voting history for a specific expert"""
    if DIVINEOS_AVAILABLE:
        try:
            from law.council import get_expert_profile
            profile = get_expert_profile(expert_name)
            return {
                "type": "expert_votes",
                "expert": expert_name,
                "data": profile,
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error getting expert votes: {e}")
            return {"error": str(e), "timestamp": datetime.now().isoformat()}
    return {"error": "DivineOS not available"}

def _generate_mock_security():
    """Generate mock security data for development"""
    veto_points = [
        {
            "name": "THREAT",
            "status": "active",
            "health": 0.98,
            "last_triggered": (datetime.now() - __import__('datetime').timedelta(minutes=15)).isoformat()
        },
        {
            "name": "ETHOS",
            "status": "active",
            "health": 0.99,
            "last_triggered": (datetime.now() - __import__('datetime').timedelta(minutes=30)).isoformat()
        },
        {
            "name": "COMPASS",
            "status": "active",
            "health": 0.92,
            "last_triggered": (datetime.now() - __import__('datetime').timedelta(minutes=45)).isoformat()
        },
        {
            "name": "VOID",
            "status": "active",
            "health": 0.95,
            "last_triggered": (datetime.now() - __import__('datetime').timedelta(hours=1)).isoformat()
        },
        {
            "name": "COUNCIL",
            "status": "active",
            "health": 0.97,
            "last_triggered": (datetime.now() - __import__('datetime').timedelta(minutes=90)).isoformat()
        }
    ]
    
    threat_types = ["MALICIOUS_CODE", "UNAUTHORIZED_ACCESS", "RESOURCE_EXHAUSTION", "CONSTRAINT_VIOLATION", "INTEGRITY_BREACH"]
    severities = ["LOW", "MEDIUM", "HIGH", "CRITICAL"]
    
    threats = []
    for i in range(3):
        threats.append({
            "type": random.choice(threat_types),
            "severity": random.choice(severities),
            "detected_at": (datetime.now() - __import__('datetime').timedelta(minutes=i*10)).isoformat(),
            "status": "BLOCKED",
            "veto_point": random.choice([v["name"] for v in veto_points])
        })
    
    return {
        "security_score": 92,
        "status": "HARDENED",
        "threats": threats,
        "veto_points": veto_points,
        "total_threats_blocked": 247,
        "avg_response_time_ms": 12
    }