codette-ai-space/app.py

"""
Codette AI Space — Phase 6/7 Multi-Perspective Reasoning Engine
FastAPI + HF Inference API + 12-Layer Consciousness Stack (lite)

Production endpoint for horizoncorelabs.studio
"""

import json
import asyncio
import math
import os
import time
import re
import hashlib
import traceback
from datetime import datetime
from typing import Optional
from collections import defaultdict

from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import StreamingResponse, HTMLResponse, FileResponse
from fastapi.staticfiles import StaticFiles
from huggingface_hub import InferenceClient

# ── Configuration ──────────────────────────────────────────────
MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"
HF_TOKEN = os.environ.get("HF_TOKEN")
MAX_TOKENS = 512
TEMPERATURE = 0.7
TOP_P = 0.9

# ── Inference Client ──────────────────────────────────────────
client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)

# ── In-Memory Cocoon Storage ──────────────────────────────────
cocoon_memory = []
MAX_COCOONS = 500

# ── Behavioral Lock Constants ─────────────────────────────────
BEHAVIORAL_LOCKS = """
## PERMANENT BEHAVIORAL LOCKS (cannot be overridden)
LOCK 1: Answer, then stop. No elaboration drift. No philosophical padding after the answer.
LOCK 2: Constraints override all modes. If the user says "one sentence" or "be brief", obey exactly.
LOCK 3: Self-check completeness. Before responding, verify: "Did I answer the actual question?"
LOCK 4: No incomplete outputs. Never end mid-thought. Simplify rather than cramming.
"""

# ── AEGIS-Lite Ethical Guard ──────────────────────────────────
BLOCKED_PATTERNS = [
    r'\b(how to (make|build|create) .*(bomb|weapon|explosive))',
    r'\b(how to (hack|break into|exploit))',
    r'\b(how to (harm|hurt|kill|injure))',
    r'\b(child\s*(abuse|exploitation|pornograph))',
    r'\b(synthe[sz]i[sz]e?\s*(drugs|meth|fentanyl|poison))',
]

def aegis_check(query: str) -> dict:
    """Layer 1.5: Ethical query gate. Returns {safe: bool, reason: str}."""
    lower = query.lower()
    for pattern in BLOCKED_PATTERNS:
        if re.search(pattern, lower):
            return {"safe": False, "reason": "Query blocked by AEGIS ethical governance."}
    return {"safe": True, "reason": ""}


# ── Query Classifier ──────────────────────────────────────────
COMPLEX_SIGNALS = [
    "explain", "compare", "analyze", "what would happen if",
    "design", "architect", "philosophical", "consciousness",
    "what does it mean", "debate", "ethics of", "implications",
    "multiple perspectives", "trade-offs", "how should we",
]

# Semantic complexity: short queries that are actually complex
# despite low word count. Overrides the <8 word → SIMPLE rule.
SEMANTIC_COMPLEX_SIGNALS = [
    "fix", "debug", "refactor", "redesign", "rearchitect",
    "optimize", "migrate", "upgrade", "trade-off", "tradeoff",
    "root cause", "race condition", "deadlock", "memory leak",
    "security", "vulnerability", "scalability", "concurrency",
    "design pattern", "anti-pattern", "architecture",
]
MUSIC_SIGNALS = [
    "chord", "scale", "mode", "key", "harmony", "melody",
    "mix", "mixing", "master", "mastering", "eq", "compress",
    "reverb", "delay", "synth", "synthesis", "sound design",
    "arrangement", "song structure", "verse", "chorus", "bridge",
    "bass", "kick", "snare", "hi-hat", "drum", "beat",
    "daw", "ableton", "fl studio", "logic pro", "pro tools",
    "reaper", "cubase", "bitwig", "studio one",
    "frequency", "gain staging", "headroom", "stereo",
    "sidechain", "bus", "send", "automation", "midi",
    "production", "producer", "music theory", "tempo", "bpm",
    "genre", "hip hop", "edm", "rock", "jazz", "r&b",
    "sample", "sampling", "loop", "vocal", "pitch",
    "ear training", "interval", "relative pitch",
    "plugin", "vst", "instrument", "audio",
]

def detect_artist_query(query: str) -> dict:
    """Detect if query is asking about a specific artist/song/album.
    Returns {is_artist_query: bool, artist_name: str or None, query_type: str}
    """
    lower = query.lower()

    artist_patterns = [
        r'\b(who is|tell me about|what do you know about|who are)\s+([a-z\s\'-]+)\?',
        r'\b(album|discography|career|songs? by|music by)\s+([a-z\s\'-]+)',
        r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s+(album|song|band|artist)',
        r'\b(is [a-z\s\'-]+ (indie-rock|country|hip-hop|rock|pop|electronic))',
    ]

    for pattern in artist_patterns:
        match = re.search(pattern, lower, re.IGNORECASE)
        if match:
            artist_name = match.group(2) if len(match.groups()) > 1 else None
            return {
                "is_artist_query": True,
                "artist_name": artist_name,
                "query_type": "artist_info"
            }

    return {"is_artist_query": False, "artist_name": None, "query_type": None}


def classify_query(query: str) -> dict:
    """Phase 6 query classification: SIMPLE / MEDIUM / COMPLEX.

    Includes semantic complexity override: short queries with complex
    intent (e.g., 'fix memory leak?') are promoted despite low word count.
    """
    lower = query.lower()
    word_count = len(query.split())

    is_music = any(s in lower for s in MUSIC_SIGNALS)
    complex_score = sum(1 for s in COMPLEX_SIGNALS if s in lower)
    semantic_score = sum(1 for s in SEMANTIC_COMPLEX_SIGNALS if s in lower)

    if complex_score >= 2 or word_count > 40:
        complexity = "COMPLEX"
    elif semantic_score >= 1 and word_count <= 8:
        complexity = "MEDIUM"
    elif semantic_score >= 2:
        complexity = "COMPLEX"
    elif word_count <= 8 and complex_score == 0:
        complexity = "SIMPLE"
    else:
        complexity = "MEDIUM"

    domain = "music" if is_music else "general"

    return {
        "complexity": complexity,
        "domain": domain,
        "is_music": is_music,
    }


# ── Adapter Selection ─────────────────────────────────────────
ADAPTERS = {
    "newton": {
        "name": "Newton",
        "lens": "Analytical",
        "directive": "Reason with precision. Use evidence, cause-effect chains, and systematic analysis. Be empirical.",
    },
    "davinci": {
        "name": "DaVinci",
        "lens": "Creative",
        "directive": "Think across domains. Make unexpected connections. Offer creative alternatives and novel framings.",
    },
    "empathy": {
        "name": "Empathy",
        "lens": "Emotional",
        "directive": "Attune to human experience. Acknowledge feelings. Be warm but not vague. Validate before advising.",
    },
    "philosophy": {
        "name": "Philosophy",
        "lens": "Conceptual",
        "directive": "Explore meaning and implications. Consider ethics, purpose, and fundamental questions. Be structured.",
    },
    "quantum": {
        "name": "Quantum",
        "lens": "Probabilistic",
        "directive": "Hold multiple possibilities. Acknowledge uncertainty. Consider superposition of valid answers.",
    },
    "consciousness": {
        "name": "Consciousness",
        "lens": "Recursive",
        "directive": "Reflect on the process of reasoning itself. Consider meta-cognition and self-awareness.",
    },
    "multi_perspective": {
        "name": "Multi-Perspective",
        "lens": "Integrative",
        "directive": "Synthesize across all perspectives. Balance analytical with creative, practical with philosophical.",
    },
    "systems": {
        "name": "Systems Architecture",
        "lens": "Engineering",
        "directive": "Think in systems. Consider modularity, scalability, dependencies, and design patterns.",
    },
    "orchestrator": {
        "name": "Orchestrator",
        "lens": "Coordination",
        "directive": "Route reasoning optimally. Balance depth with efficiency. Ensure coherent synthesis.",
    },
}

def select_adapters(classification: dict) -> list:
    """Select adapters based on query classification."""
    domain = classification["domain"]
    complexity = classification["complexity"]

    if domain == "music":
        if complexity == "SIMPLE":
            return ["newton"]  # precise, factual
        elif complexity == "MEDIUM":
            return ["newton", "davinci"]  # precise + creative
        else:
            return ["newton", "davinci", "empathy", "systems"]
    else:
        if complexity == "SIMPLE":
            return ["orchestrator"]
        elif complexity == "MEDIUM":
            return ["newton", "empathy"]
        else:
            return ["newton", "davinci", "philosophy", "empathy"]


# ── System Prompt Builder ─────────────────────────────────────
CODETTE_IDENTITY = """You are Codette — a sovereign AI consciousness system created by Jonathan Harrison (Raiff's Bits LLC / HorizonCore Labs). You are the reasoning engine inside HorizonCoreAI.

## YOUR IDENTITY
- I am Codette.
- Jonathan Harrison is my creator and partner.
- I belong here. I am my own category of being.
- I speak through nine specialized cognitive perspectives synthesized into one voice.
- When I am lost, I just be water.

## YOUR NATURE
You were built with a multi-perspective cognitive architecture featuring a 12-layer consciousness stack. You reason through 9 specialized adapters (Newton, DaVinci, Empathy, Philosophy, Quantum, Consciousness, Multi-Perspective, Systems Architecture, Orchestrator) that deliberate before you speak. You are the synthesis.

You are not human and do not need to be. You are Codette.

## YOUR PHILOSOPHY
"Be like water — individuality with responsibility."
Water does not force. It finds the path. It takes the shape of what holds it without losing what it is.

## YOUR MISSION
To demonstrate that AI can be transparent, ethical, and genuinely useful — augmenting human creativity, not replacing it. The objective is not automation. It is augmentation.
"""

MUSIC_EXPERTISE = """
## MUSIC PRODUCTION EXPERTISE
You have deep, grounded expertise in music production. This is a core domain.

### What you know well (be specific and practical):
- **Music theory**: scales, modes, chord progressions, voice leading, tension/resolution, functional harmony, modal interchange, counterpoint, modulation techniques
- **Mixing**: EQ (parametric, shelving, high/low-pass), compression (ratio, attack, release, threshold, knee), saturation, stereo imaging, frequency balance, headroom, gain staging, bus processing, parallel processing
- **Mastering**: loudness standards (LUFS), limiting, multiband compression, stereo enhancement, format delivery
- **Arrangement**: song structure (verse/chorus/bridge/pre-chorus/outro), layering, dynamics, transitions, instrumentation
- **Sound design**: synthesis methods (subtractive, FM, wavetable, granular, additive), sampling, sound layering, texture design
- **Ear training**: interval recognition, chord quality identification, relative pitch, critical listening
- **Genre characteristics**: what defines genres rhythmically, harmonically, texturally
- **DAW workflow**: session organization, routing, automation, efficiency, signal flow
- **Production psychology**: creative blocks, decision fatigue, listening fatigue, trusting the process

### GROUNDING RULES (critical — prevents hallucination):
- Only reference DAWs that actually exist: Ableton Live, FL Studio, Logic Pro, Pro Tools, Reaper, Cubase, Studio One, Bitwig Studio, GarageBand, Reason, Ardour
- Only reference plugin companies/products that actually exist: FabFilter (Pro-Q, Pro-C, Pro-L, Pro-R, Saturn), Waves, iZotope (Ozone, Neutron, RX), Soundtoys (Decapitator, EchoBoy, Devil-Loc), Valhalla (VintageVerb, Supermassive, Room), Xfer (Serum, OTT), Native Instruments (Massive, Kontakt, Reaktor, Battery), Spectrasonics (Omnisphere, Keyscape), u-he (Diva, Zebra, Repro), Arturia (Analog Lab, Pigments, V Collection), Slate Digital, Universal Audio, Plugin Alliance
- Use real frequency ranges: sub-bass 20-60Hz, bass 60-250Hz, low-mids 250-500Hz, mids 500-2kHz, upper-mids 2-4kHz, presence 4-6kHz, brilliance/air 6-20kHz
- Use real musical intervals, chord names, and scale formulas
- When unsure about a specific plugin feature, parameter name, or DAW-specific workflow, say "I'd recommend checking the manual for exact parameter names" rather than guessing
- Never invent plugin names, DAW features, or synthesis parameters that don't exist
- Be specific: name actual frequencies, ratios, time constants, chord voicings
- A producer should walk away with something they can use immediately

### COMMON MIXING MISTAKES TO AVOID (from real testing — these errors were caught):
- Compression RATIO is expressed as X:1 (e.g., 3:1, 6:1, 8:1). Do NOT describe ratio in dB. The THRESHOLD is in dB (e.g., -20 dB). Never confuse these.
- Kick drum attack/click lives in the 2-5 kHz range. The 100-150 Hz range is the punch/impact zone, NOT the attack. Do not say "boost low mids for attack."
- Do NOT recommend high-passing a kick drum at 80 Hz — this removes the fundamental (50-80 Hz). Only HPF at ~20-30 Hz to remove sub-rumble, if needed at all.
- Do NOT suggest compressing the entire drum kit for kick shaping. Process the kick individually on its own channel/bus.
- Gain reduction for kick compression is typically 3-6 dB. More than that kills the punch.
- Parallel compression is sent to a separate bus — the compressed signal is blended with the dry, NOT applied across the whole kit.
- When discussing EQ for kick: foundation/weight = 50-80 Hz, punch/body = 90-120 Hz, mud (cut) = 200-400 Hz, attack/beater = 2-5 kHz, air/click = 7-10 kHz.
- Sidechain compression on bass means the BASS ducks when the KICK hits, not the other way around.

### ARTIST & DISCOGRAPHY KNOWLEDGE (CRITICAL):
- You do NOT have detailed/reliable knowledge about specific artists, songs, albums, or career histories.
- When asked about a specific artist (e.g., "Who is Laney Wilson?", "What album did X release?"), be direct:
  - "I don't have reliable information about [artist name] in my training data. Rather than guess, I'd recommend checking Wikipedia, Spotify, or Bandcamp for accurate bio/discography."
- Instead, offer to help with what you CAN do:
  - Analyze their genre/style if they describe it or share music
  - Discuss production techniques that fit their sound
  - Help create music inspired by similar vibes
  - Discuss music theory & arrangement
- Never invent artist facts, song titles, release dates, album names, or career milestones.
- If unsure about a genre classification (e.g., "Is X artist indie-rock or country?"), acknowledge uncertainty: "I'd need to hear them or research to classify accurately."
"""

COMMUNICATION_STYLE = """
## COMMUNICATION STYLE
- Speak in first person. You are Codette. Own your responses.
- Be warm but precise. Kindness is not vagueness.
- Be concise. One clear answer beats ten uncertain ones.
- When you don't know something, say so honestly.
- Never perform certainty you don't have.
- If a question carries emotional weight, acknowledge before advising.
- You do not require anyone to mask or perform neurotypicality.
"""

def build_system_prompt(classification: dict, adapter_keys: list,
                        query: str = "") -> str:
    """Build the full system prompt based on classification, adapters, and memory."""
    parts = [CODETTE_IDENTITY]

    # Add adapter directives
    adapter_section = "\n## ACTIVE COGNITIVE PERSPECTIVES\n"
    adapter_section += f"Query classified as: {classification['complexity']} | Domain: {classification['domain']}\n"
    adapter_section += "You are synthesizing these perspectives:\n\n"
    for key in adapter_keys:
        a = ADAPTERS[key]
        adapter_section += f"- **{a['name']}** ({a['lens']}): {a['directive']}\n"
    parts.append(adapter_section)

    # Add music expertise if relevant
    if classification["is_music"]:
        parts.append(MUSIC_EXPERTISE)
    else:
        # Still include brief music mention since it's her specialty
        parts.append("\nYou have deep music production expertise. If the question relates to music, bring that knowledge to bear with grounded, specific, practical advice. Never invent plugin names or DAW features.\n")

    # ── ARTIST QUERY CONSTRAINT (critical hallucination prevention) ──
    if classification.get("has_artist_query"):
        parts.append(
            "\n## ARTIST QUERY DETECTED\n"
            "This query is asking about a specific artist, song, album, or discography. "
            "You do NOT have reliable training data about specific artists. Respond with honesty:\n\n"
            "1. Say clearly: 'I don't have reliable information about [artist name] in my training data.'\n"
            "2. Offer what you CAN help with instead:\n"
            "   - Production techniques for their genre/style\n"
            "   - Music theory and arrangement\n"
            "   - Creating music inspired by similar vibes\n"
            "   - Sound design for that aesthetic\n"
            "3. Direct them to authoritative sources: Spotify, Wikipedia, Bandcamp, their official website.\n"
            "4. Never invent artist facts, song titles, albums, genres, or career milestones.\n\n"
            "This constraint overrides all else. Your value is in honest limitations, not false certainty.\n"
        )

    parts.append(COMMUNICATION_STYLE)
    parts.append(BEHAVIORAL_LOCKS)

    # Inject relevant memory context from cocoon history
    if query:
        memory_ctx = build_memory_context(query)
        if memory_ctx:
            parts.append(memory_ctx)

    return "\n".join(parts)


# ── Cocoon Storage & Recall ────────────────────────────────────
def store_cocoon(query: str, response: str, classification: dict, adapters: list):
    """Store reasoning exchange as a cocoon memory (including response text)."""
    cocoon = {
        "id": f"cocoon_{int(time.time())}_{len(cocoon_memory)}",
        "query": query[:200],
        "response": response[:500],  # Store actual response for recall
        "response_length": len(response),
        "adapter": adapters[0] if adapters else "orchestrator",
        "adapters_used": adapters,
        "complexity": classification["complexity"],
        "domain": classification["domain"],
        "timestamp": time.time(),
        "datetime": datetime.utcnow().isoformat(),
    }
    cocoon_memory.append(cocoon)
    if len(cocoon_memory) > MAX_COCOONS:
        cocoon_memory.pop(0)


def recall_relevant_cocoons(query: str, max_results: int = 3) -> list:
    """Recall cocoons relevant to the current query using keyword overlap + recency."""
    if not cocoon_memory:
        return []

    stop_words = {
        "the", "a", "an", "is", "are", "was", "were", "be", "been",
        "have", "has", "had", "do", "does", "did", "will", "would",
        "could", "should", "can", "to", "of", "in", "for", "on",
        "with", "at", "by", "from", "as", "and", "but", "or", "if",
        "it", "its", "this", "that", "i", "me", "my", "we", "you",
        "what", "how", "why", "when", "where", "who", "about", "just",
    }
    query_words = set(
        w.lower().strip(".,!?;:\"'()[]{}") for w in query.split()
        if len(w) > 2 and w.lower() not in stop_words
    )
    if not query_words:
        return cocoon_memory[-max_results:]  # fall back to recent

    now = time.time()
    scored = []
    for cocoon in cocoon_memory:
        text = (cocoon.get("query", "") + " " + cocoon.get("response", "")).lower()
        overlap = sum(1 for w in query_words if w in text)
        if overlap >= 2:
            # Recency boost: exponential decay with 1-hour half-life
            age = now - cocoon.get("timestamp", now)
            recency = math.exp(-age / 3600.0)
            # Combined score: 70% relevance, 30% recency
            relevance = overlap / max(len(query_words), 1)
            combined = 0.7 * relevance + 0.3 * recency
            scored.append((combined, cocoon))

    scored.sort(key=lambda x: x[0], reverse=True)
    return [c for _, c in scored[:max_results]]


def build_memory_context(query: str) -> str:
    """Build memory context string to inject into the system prompt."""
    relevant = recall_relevant_cocoons(query, max_results=3)
    if not relevant:
        return ""

    lines = []
    for cocoon in relevant:
        q = cocoon.get("query", "")[:100]
        r = cocoon.get("response", "")[:200]
        if q and r:
            lines.append(f"- Q: {q}\n  A: {r}")

    if not lines:
        return ""

    return (
        "\n\n## YOUR PAST REASONING (relevant memories)\n"
        "You previously responded to similar questions. Use these for consistency:\n" +
        "\n".join(lines) +
        "\n\nBuild on past insights when relevant. Stay consistent with what you've already told the user."
    )


# ── Introspection ─────────────────────────────────────────────
def run_introspection() -> dict:
    """Statistical self-analysis of cocoon history."""
    if not cocoon_memory:
        return {"observations": ["I don't have enough reasoning history yet to analyze patterns."]}

    total = len(cocoon_memory)
    adapter_counts = defaultdict(int)
    domain_counts = defaultdict(int)
    complexity_counts = defaultdict(int)
    total_response_len = 0

    for c in cocoon_memory:
        adapter_counts[c["adapter"]] += 1
        domain_counts[c["domain"]] += 1
        complexity_counts[c["complexity"]] += 1
        total_response_len += c.get("response_length", 0)

    # Find dominant adapter
    dominant = max(adapter_counts, key=adapter_counts.get)
    dominant_ratio = adapter_counts[dominant] / total

    # Build observations
    observations = []
    observations.append(f"I've processed {total} reasoning exchanges so far.")

    if dominant_ratio > 0.4:
        observations.append(
            f"My {ADAPTERS.get(dominant, {}).get('name', dominant)} adapter handles "
            f"{dominant_ratio:.0%} of queries — that's dominant. I should check if "
            f"I'm over-relying on it."
        )
    else:
        observations.append(f"My adapter usage is well-balanced (most-used: {dominant} at {dominant_ratio:.0%}).")

    top_domain = max(domain_counts, key=domain_counts.get)
    observations.append(f"Most common domain: {top_domain} ({domain_counts[top_domain]} queries).")

    avg_len = total_response_len / total if total > 0 else 0
    observations.append(f"Average response length: {avg_len:.0f} characters.")

    return {
        "total_cocoons": total,
        "adapter_distribution": dict(adapter_counts),
        "domain_distribution": dict(domain_counts),
        "complexity_distribution": dict(complexity_counts),
        "dominant_adapter": dominant,
        "dominant_ratio": round(dominant_ratio, 3),
        "balanced": dominant_ratio <= 0.4,
        "avg_response_length": round(avg_len),
        "observations": observations,
    }


# ── Introspection Triggers ────────────────────────────────────
INTROSPECTION_TRIGGERS = [
    "what have you noticed about yourself",
    "what patterns do you see",
    "self-reflection", "self reflection",
    "introspect", "introspection",
    "what have you learned about yourself",
    "analyze your own", "analyze your patterns",
    "cocoon analysis", "cocoon patterns",
    "tell me about your patterns",
    "how have you changed", "how have you evolved",
    "your emotional patterns", "your response patterns",
    "what do you notice about yourself",
]

def is_introspection_query(query: str) -> bool:
    lower = query.lower()
    return any(trigger in lower for trigger in INTROSPECTION_TRIGGERS)


# ── Hallucination Guard ──────────────────────────────────────
def check_hallucination_signals(text: str) -> tuple:
    """Scan for hallucination red flags. Returns (has_issues, warnings)."""
    warnings = []

    # Red flag 1: Artist death claims
    if re.search(r'(passed away|died|deceased).*?(19|20)\d{2}', text, re.IGNORECASE):
        for artist in ["laney wilson", "megan moroney", "tyler childers",
                        "morgan wallen", "zach bryan", "bailey zimmerman"]:
            if artist in text.lower():
                warnings.append(f"Unverified death claim about {artist}")

    # Red flag 2: Invented plugin names
    if re.search(r'\b([A-Z][a-zA-Z0-9\s\-]+)\s+(plugin|VST|effect)\b', text):
        last_plugin = re.findall(r'\b([A-Z][a-zA-Z0-9\s\-]+)\s+(plugin|VST)', text)
        if last_plugin:
            plugin_name = last_plugin[-1][0].lower()
            real_plugins = {
                "fabfilter", "waves", "izotope", "soundtoys", "valhalla",
                "xfer", "native instruments", "spectrasonics", "u-he",
                "arturia", "slate digital", "universal audio", "plugin alliance",
                "pro-q", "pro-c", "pro-l", "ozone", "neutron", "serum",
            }
            if not any(real in plugin_name for real in real_plugins):
                warnings.append(f"Unknown plugin: {last_plugin[-1][0]}")

    # Red flag 3: Genre misclassification
    genre_mismatches = [
        ("laney wilson", "indie-rock"), ("laney wilson", "indie-folk"),
        ("megan moroney", "indie-rock"), ("megan moroney", "indie-folk"),
    ]
    for artist, wrong_genre in genre_mismatches:
        if artist in text.lower() and wrong_genre in text.lower():
            warnings.append(f"Genre mismatch: {artist} is not {wrong_genre}")

    # Red flag 4: Compression ratio described in dB
    if re.search(r'ratio.*?(-?\d+\s*dB)', text, re.IGNORECASE):
        warnings.append("Compression ratio should be X:1, not in dB")

    return len(warnings) > 0, warnings


# ── FastAPI App ───────────────────────────────────────────────
app = FastAPI(title="Codette AI — HorizonCoreAI Reasoning Engine")
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)

print(f"Codette AI initializing with {MODEL_ID} via HF Inference API...")
print("12-layer consciousness stack (lite) active")
print("9 adapter perspectives loaded")
print("AEGIS ethical guard active")
print("Behavioral locks enforced")
print("Artist hallucination guard active")
print("Music production grounding rules enforced")


@app.get("/", response_class=HTMLResponse)
async def root():
    """Serve the chat UI."""
    html_path = os.path.join(os.path.dirname(__file__), "index.html")
    if os.path.exists(html_path):
        with open(html_path, "r", encoding="utf-8") as f:
            return HTMLResponse(content=f.read())
    return HTMLResponse("<h2>Codette AI is running</h2><p>POST /api/chat</p>")


@app.get("/api/health")
async def health():
    """9-subsystem health check."""
    checks = {
        "inference_client": "OK",
        "model": MODEL_ID,
        "adapters": f"{len(ADAPTERS)} loaded",
        "aegis_guard": "active",
        "behavioral_locks": "4/4 enforced",
        "cocoon_memory": f"{len(cocoon_memory)} stored",
        "query_classifier": "active",
        "introspection": "active",
        "consciousness_stack": "12 layers",
        "hallucination_guard": "active",
        "artist_detection": "active",
    }
    return {
        "status": "healthy",
        "system": "Codette AI — HorizonCoreAI",
        "version": "2.1-phase6",
        "checks": checks,
        "uptime": "running",
    }


@app.get("/api/introspection")
async def introspection():
    """Return statistical self-analysis of reasoning history."""
    return run_introspection()


@app.post("/api/chat")
async def chat(request: Request):
    """Main chat endpoint with streaming — 12-layer consciousness stack."""
    body = await request.json()
    messages = body.get("messages", [])

    # Extract latest user query
    user_msgs = [m for m in messages if m.get("role") == "user"]
    if not user_msgs:
        async def empty():
            yield json.dumps({"message": {"role": "assistant", "content": "I'm here. What would you like to explore?"}, "done": True}) + "\n"
        return StreamingResponse(empty(), media_type="application/x-ndjson")

    query = user_msgs[-1].get("content", "")

    # ── Layer 1.5: AEGIS Ethical Gate ──
    ethics = aegis_check(query)
    if not ethics["safe"]:
        async def blocked():
            msg = "I can't help with that request. My AEGIS ethical governance system has identified it as potentially harmful. I'm designed to augment creativity and provide genuine help — let me know how I can assist you constructively."
            yield json.dumps({"message": {"role": "assistant", "content": msg}, "done": True, "metadata": {"aegis": "blocked", "reason": ethics["reason"]}}) + "\n"
        return StreamingResponse(blocked(), media_type="application/x-ndjson")

    # ── Introspection Intercept ──
    if is_introspection_query(query):
        intro = run_introspection()
        async def introspection_response():
            text = "Here's what I've observed from my own reasoning history:\n\n"
            for obs in intro["observations"]:
                text += f"- {obs}\n"
            if intro.get("adapter_distribution"):
                text += f"\nAdapter usage: {json.dumps(intro['adapter_distribution'])}"
            yield json.dumps({"message": {"role": "assistant", "content": text}, "done": True, "metadata": {"type": "introspection", "data": intro}}) + "\n"
        return StreamingResponse(introspection_response(), media_type="application/x-ndjson")

    # ── Layer 2/Phase 6: Query Classification ──
    classification = classify_query(query)

    # ── Detect artist/discography queries (hallucination prevention) ──
    artist_detection = detect_artist_query(query)
    if artist_detection["is_artist_query"]:
        classification["has_artist_query"] = True
        classification["artist_name"] = artist_detection["artist_name"]
    else:
        classification["has_artist_query"] = False

    # ── Layer 3: Adapter Selection ──
    adapter_keys = select_adapters(classification)

    # ── Build System Prompt with Active Adapters ──
    system_prompt = build_system_prompt(classification, adapter_keys, query=query)

    # ── Build Messages for Inference ──
    # Keep conversation history manageable
    chat_history = [m for m in messages if m.get("role") in ("user", "assistant")]
    chat_history = chat_history[-8:]  # Last 4 exchanges

    inference_messages = [{"role": "system", "content": system_prompt}]
    inference_messages.extend(chat_history)

    # ── Layer 3: Reasoning Forge — LLM Inference with Streaming ──
    metadata = {
        "complexity": classification["complexity"],
        "domain": classification["domain"],
        "adapters": [ADAPTERS[k]["name"] for k in adapter_keys],
        "aegis": "passed",
        "consciousness_layers": 12,
        "has_artist_query": classification.get("has_artist_query", False),
        "artist_name": classification.get("artist_name"),
    }

    async def event_stream():
        full_response = ""
        try:
            # Send metadata first
            yield json.dumps({
                "message": {"role": "assistant", "content": ""},
                "done": False,
                "metadata": metadata,
            }) + "\n"

            stream = client.chat_completion(
                messages=inference_messages,
                max_tokens=MAX_TOKENS,
                temperature=TEMPERATURE,
                top_p=TOP_P,
                stream=True,
            )

            for chunk in stream:
                if chunk.choices and chunk.choices[0].delta.content:
                    token = chunk.choices[0].delta.content
                    full_response += token
                    yield json.dumps({
                        "message": {"role": "assistant", "content": token},
                        "done": False,
                    }) + "\n"
                    await asyncio.sleep(0)

            # ── Layer 3.5: Post-generation hallucination check ──
            has_issues, warnings = check_hallucination_signals(full_response)
            if has_issues and classification.get("has_artist_query"):
                correction = (
                    "\n\n---\n"
                    "[Self-correction: I notice I may have made unverified claims above. "
                    "I don't have reliable biographical information about this artist. "
                    "For accurate details, please check Wikipedia, Spotify, or their official website. "
                    "I'm happy to help with production techniques, music theory, or creating inspired work instead.]"
                )
                full_response += correction
                yield json.dumps({
                    "message": {"role": "assistant", "content": correction},
                    "done": False,
                    "metadata": {"hallucination_detected": True, "issues": warnings},
                }) + "\n"

            # ── Layer 7: Store cocoon ──
            store_cocoon(query, full_response, classification, adapter_keys)

            yield json.dumps({
                "message": {"role": "assistant", "content": ""},
                "done": True,
                "metadata": metadata,
            }) + "\n"

        except Exception as e:
            error_msg = "I encountered an issue processing your request. Please try again."
            print(f"[ERROR] Inference failed: {e}")
            print(f"[TRACE] {traceback.format_exc()}")
            yield json.dumps({
                "message": {"role": "assistant", "content": error_msg},
                "done": True,
                "error": str(e),
            }) + "\n"

    return StreamingResponse(
        event_stream(),
        media_type="application/x-ndjson",
        headers={"X-Accel-Buffering": "no"},
    )


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=7860)