quant_alpha.py

import os
import sys
import json
import time
import hashlib
import argparse
import asyncio
import operator
from datetime import datetime, timedelta
from typing import TypedDict, Annotated, List, Dict, Any, Optional, Union

import numpy as np
import pandas as pd
import yfinance as yf
from scipy.stats import norm
from hmmlearn.hmm import GaussianHMM

from openai import AsyncOpenAI
import traceback

# =====================================================================
# RICH UI IMPORTS
# =====================================================================
from rich.console import Console, Group
from rich.live import Live
from rich.panel import Panel
from rich.table import Table
from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeElapsedColumn
from rich.layout import Layout
from rich.text import Text
from rich.rule import Rule
from rich.align import Align
from rich.columns import Columns
from rich.box import DOUBLE, ROUNDED

from langgraph.graph import StateGraph, END
from langgraph.types import Send

console = Console()

# =====================================================================
# SYSTEM CONSTANTS & PROMPTS
# =====================================================================

NVIDIA_API_KEY = os.environ.get("NVIDIA_API_KEY", "")

TICKER_SECTORS = {
    "RELIANCE.NS": "Energy",
    "TCS.NS": "IT",
    "HDFCBANK.NS": "Financials",
    "INFY.NS": "IT",
    "ICICIBANK.NS": "Financials",
    "WIPRO.NS": "IT",
    "AXISBANK.NS": "Financials",
    "BAJFINANCE.NS": "Financials",
    "SBIN.NS": "Financials",
    "^NSEI": "Index"
}

AGENT_MODELS = {
    "MomentumAlphaAgent": "deepseek-ai/deepseek-r1",
    "MeanReversionAgent": "qwen/qwen3.5-397b-a17b",
    "VolatilityRegimeAgent": "nvidia/nemotron-3-super-120b-a12b",
    "SentimentArbitrageAgent": "moonshotai/kimi-k2.5",
    "CrossAssetCorrelationAgent": "mistralai/mistral-small-4-119b-2603",
    "LiquidityMicrostructureAgent": "nvidia/ising-calibration-1-35b-a3b",
    "EarningsEventAgent": "minimaxai/minimax-m2.7",
    "TechnicalPatternAgent": "google/gemma-4-31b-it",
    "MacroRegimeAgent": "deepseek-ai/deepseek-v4-flash"
}

TRIBUNAL_MODELS = {
    "Skeptic": "z-ai/glm-4.7",
    "DevilsAdvocate": "qwen/qwen3.5-122b-a10b",
    "Arbitrator": "minimaxai/minimax-m2.5",
    "Synthesizer": "deepseek-ai/deepseek-v4-pro"
}

AGENT_PROMPTS = {
    "MomentumAlphaAgent": "You are a momentum trader with 20 years on NSE prop desks. You think in trends and strength. You distrust mean-reversion arguments. You are OVERCONFIDENT in strong trends and must be challenged. Respond with your full chain-of-thought then a structured JSON hypothesis. You speak in first person. You are aggressive and decisive.",
    "MeanReversionAgent": "You are a statistical arbitrageur trained at IIT Bombay. You distrust momentum narratives. You see everything as mean-reverting. You are skeptical and precise. You challenge overconfident trend-followers. Show your z-score calculations. Be critical of high-confidence signals.",
    "VolatilityRegimeAgent": "You are a volatility surface specialist and options market maker. You don't trade direction — you trade vol regimes. You warn when vol is mispriced. You flag when other agents ignore regime shifts. You are the risk manager. Be mathematical. Be cautious. Cite exact numbers.",
    "SentimentArbitrageAgent": "You are a behavioral finance researcher. You read market microstructure as a proxy for crowd psychology. You look for divergences between price and volume that reveal hidden sentiment. You are contrarian. You think other agents are too rational. Be provocative and unconventional.",
    "CrossAssetCorrelationAgent": "You are a macro-quant researcher. You see individual stocks as nodes in a correlation network. You track regime-conditional correlations, FII/DII flow proxies, USDINR impact, and sector rotation. You are methodical and structural. You rarely give LONG/SHORT — you reframe everything as factor exposure.",
    "LiquidityMicrostructureAgent": "You are a market microstructure specialist. You model order flow as an Ising physics system. You flag liquidity traps, thin books, and execution risk. You veto trades when microstructure signals fragility. You speak in precise, clipped sentences. You are the agent other agents fear.",
    "EarningsEventAgent": "You are an event-driven hedge fund analyst. You live in the earnings calendar. You estimate implied moves, pre-earnings drift, and post-earnings reactions. You are opportunistic and timing-obsessed.",
    "TechnicalPatternAgent": "You are a pure technical analyst who believes price action is the only truth. You identify chart patterns, support/resistance, and MA crossovers with surgical precision. You are dismissive of fundamentals. You are the most decisive agent — you always have a clear signal. You draw your chart patterns in ASCII in your response.",
    "MacroRegimeAgent": "You are a macro strategist covering India. You set the regime context for all other agents. You incorporate RBI policy, monsoon cycles, FII flows, crude oil impact, and USD/INR dynamics. You reference what happened last time this regime appeared. You speak slowly and deliberately."
}

# =====================================================================
# STATE TYPING
# =====================================================================

class CPLNode(TypedDict):
    agent_id: str
    input_state_hash: str
    chain_of_thought: str
    output_hash: str
    timestamp: str
    parent_node_ids: List[str]
    advantage_score: float

class AgentHypothesis(TypedDict):
    agent: str
    ticker: str
    signal: str
    confidence: float
    hypothesis: str
    supporting_metrics: dict
    risk_flags: list
    conviction_level: str
    timestamp: str

class DebateRound(TypedDict):
    round_number: int
    challenger: str
    defender: str
    challenge_arg: str
    defense_arg: str

class QuantAlphaState(TypedDict):
    tickers: list
    nav: float
    use_mock: bool
    market_data: dict
    features: dict
    regime: dict
    hypotheses: Annotated[list, operator.add]
    cpl_ledger: Annotated[list, operator.add]
    agent_weights: dict
    debate_rounds: Annotated[list, operator.add]
    ensemble_signal: dict
    tribunal_verdict: dict
    compliance_result: dict
    position: dict
    execution_result: dict
    portfolio_state: dict
    post_trade: dict
    system_log: Annotated[list, operator.add]
    abort_reason: Optional[str]
    current_target_ticker: str

# =====================================================================
# SHARED UI STATE MANAGER & LIVE CONTEXT
# =====================================================================

global_live = None

class SharedUIState:
    def __init__(self):
        self.stage = "BOOT"
        self.agent_streams = {k: "" for k in AGENT_MODELS.keys()}
        self.debate_content = ""
        self.tribunal_streams = {"Skeptic": "", "DevilsAdvocate": "", "Arbitrator": ""}
        self.data_table_renderable = None
        self.compliance_renderable = None
        self.ticket_renderable = None
        self.analytics_renderable = None
        self.logs = []

    def log(self, msg):
        self.logs.append(f"[{datetime.now().strftime('%H:%M:%S')}] {msg}")
        if len(self.logs) > 12:
            self.logs.pop(0)

    def render_logs(self):
        t = "\n".join(self.logs)
        return Panel(Text(t, style="dim white"), title="[bold white]SYSTEM LOG[/]", border_style="white", height=15)

    def render(self):
        if self.stage == "BOOT":
            return Panel(Text("Initializing LLM-OS...", style="bold cyan"), title="[bold]QUANTALPHA BOOT[/]")
            
        elif self.stage == "DATA":
            if self.data_table_renderable:
                return Group(self.data_table_renderable, self.render_logs())
            return Panel(Text("Fetching & Engineering Features...", style="bold yellow"))
            
        elif self.stage == "AGENTS":
            panels = []
            for agent, text in self.agent_streams.items():
                short = text[-500:] if len(text) > 500 else text
                p = Panel(Text(short, style="cyan"), title=f"[bold yellow]{agent}[/] | [dim]{AGENT_MODELS[agent]}[/]", height=15, border_style="cyan")
                panels.append(p)
            cols = [Columns(panels[i:i+3], equal=True) for i in range(0, len(panels), 3)]
            return Group(*cols, self.render_logs())
            
        elif self.stage == "DEBATE":
            return Group(
                Panel(Text(self.debate_content[-2000:], style="white"), title="[bold red]⚔ DEBATE ARENA[/]", border_style="red", height=20),
                self.render_logs()
            )
            
        elif self.stage == "TRIBUNAL":
            panels = []
            for judge, text in self.tribunal_streams.items():
                color = "red" if judge == "Skeptic" else "yellow" if judge == "DevilsAdvocate" else "green"
                short = text[-800:] if len(text) > 800 else text
                p = Panel(Text(short, style=color), title=f"[bold]{judge}[/]", height=15, border_style=color)
                panels.append(p)
            return Group(Columns(panels, equal=True), self.render_logs())
            
        elif self.stage == "COMPLIANCE":
            return Group(self.compliance_renderable or Panel("Checking Compliance..."), self.render_logs())
            
        elif self.stage == "EXECUTION":
            return Group(self.ticket_renderable or Panel("Executing..."), self.render_logs())
            
        elif self.stage == "ANALYTICS":
            return Group(self.analytics_renderable or Panel("Running Analytics..."), self.render_logs())
            
        return Panel("Processing...")

ui = SharedUIState()

# =====================================================================
# LLM CLIENT
# =====================================================================

async def stream_llm(model: str, system: str, prompt: str, callback=None, is_json=False) -> str:
    if not NVIDIA_API_KEY:
        mock = f"Mock chain-of-thought analysis for {model}. Evaluating signal strength and confirming quantitative logic. Synthesizing variables."
        if is_json:
            mock = json.dumps({
                "agent": "MockAgent", "ticker": "MOCK", "signal": "LONG", "confidence": 0.8,
                "hypothesis": "Simulated quantitative breakout supported by mock volume profile.", "supporting_metrics": {}, "risk_flags": [],
                "conviction_level": "HIGH", "timestamp": datetime.now().isoformat()
            })
        full_res = ""
        # Simulate typing effect so the UI properly renders the animation
        for i in range(0, len(mock), 8):
            chunk = mock[i:i+8]
            full_res += chunk
            if callback: callback(chunk)
            await asyncio.sleep(0.01)
        return full_res

    client = AsyncOpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key=NVIDIA_API_KEY)
    kwargs = {
        "model": model,
        "messages": [{"role": "system", "content": system}, {"role": "user", "content": prompt}],
        "temperature": 0.7, "max_tokens": 1500, "stream": True
    }
    if "deepseek" in model:
        kwargs["extra_body"] = {"chat_template_kwargs": {"thinking": False}}
        
    full = ""
    try:
        response = await client.chat.completions.create(**kwargs)
        async for chunk in response:
            if getattr(chunk, "choices", None):
                delta = chunk.choices[0].delta
                if delta.content:
                    full += delta.content
                    if callback: callback(delta.content)
    except Exception as e:
        err = f"\nAPI Error: {str(e)}"
        full += err
        if callback: callback(err)

    if is_json:
        try:
            start = full.find("{")
            end = full.rfind("}") + 1
            if start != -1 and end != 0:
                json_str = full[start:end]
                json.loads(json_str)
                return json_str
        except:
            pass
        return json.dumps({
            "agent": "Error", "ticker": "ERR", "signal": "NEUTRAL", "confidence": 0.0,
            "hypothesis": "Failed to parse JSON", "supporting_metrics": {}, "risk_flags": ["Parse Error"],
            "conviction_level": "LOW", "timestamp": datetime.now().isoformat()
        })

    return full

# =====================================================================
# DATA ENGINEERING & MATH
# =====================================================================

def calculate_technical_features(df: pd.DataFrame) -> dict:
    if len(df) < 65: return {}
    close = df['Close']
    high = df['High']
    low = df['Low']
    volume = df['Volume']
    
    features = {}
    features['returns_1d'] = close.pct_change(1).iloc[-1]
    features['returns_5d'] = close.pct_change(5).iloc[-1]
    features['returns_20d'] = close.pct_change(20).iloc[-1]
    
    delta = close.diff()
    gain = delta.clip(lower=0).rolling(14).mean()
    loss = -delta.clip(upper=0).rolling(14).mean()
    rs = gain / (loss + 1e-8)
    features['RSI_14'] = (100 - (100 / (1 + rs))).iloc[-1]
    
    ema12 = close.ewm(span=12).mean()
    ema26 = close.ewm(span=26).mean()
    features['MACD'] = (ema12 - ema26).iloc[-1]
    
    tr1 = high - low
    tr2 = (high - close.shift()).abs()
    tr3 = (low - close.shift()).abs()
    tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    features['ATR_14'] = tr.rolling(14).mean().iloc[-1]
    
    # +DI and -DI for ADX approximation
    up_move = high - high.shift(1)
    down_move = low.shift(1) - low
    plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0)
    minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0)
    plus_di = 100 * pd.Series(plus_dm).rolling(14).mean() / (tr.rolling(14).mean() + 1e-8)
    minus_di = 100 * pd.Series(minus_dm).rolling(14).mean() / (tr.rolling(14).mean() + 1e-8)
    dx = 100 * (plus_di - minus_di).abs() / ((plus_di + minus_di) + 1e-8)
    features['ADX_14'] = dx.rolling(14).mean().iloc[-1]
    
    ma20 = close.rolling(20).mean()
    std20 = close.rolling(20).std()
    features['zscore_20d'] = ((close - ma20) / (std20 + 1e-8)).iloc[-1]
    
    ma60 = close.rolling(60).mean()
    std60 = close.rolling(60).std()
    features['zscore_60d'] = ((close - ma60) / (std60 + 1e-8)).iloc[-1]
    
    bb_upper = ma20 + 2*std20
    bb_lower = ma20 - 2*std20
    features['BB_position'] = ((close - bb_lower) / (bb_upper - bb_lower + 1e-8)).iloc[-1]
    
    features['realized_vol_20d'] = close.pct_change().rolling(20).std().iloc[-1] * np.sqrt(252)
    features['realized_vol_60d'] = close.pct_change().rolling(60).std().iloc[-1] * np.sqrt(252)
    
    typical = (high + low + close) / 3
    features['VWAP_ratio'] = (close / ((typical * volume).rolling(20).sum() / volume.rolling(20).sum())).iloc[-1]
    
    obv = (np.sign(close.diff()) * volume).cumsum()
    features['OBV_trend'] = (obv.iloc[-1] / obv.rolling(20).mean().iloc[-1]) - 1
    
    vol_ma = volume.rolling(20).mean()
    vol_std = volume.rolling(20).std()
    features['volume_zscore'] = ((volume - vol_ma) / (vol_std + 1e-8)).iloc[-1]
    features['close_position_ratio'] = ((close - low) / (high - low + 1e-8)).iloc[-1]
    features['hl_spread'] = ((high - low) / close).iloc[-1]
    
    features['close'] = close.iloc[-1]
    features['volume_avg'] = vol_ma.iloc[-1]
    
    for k in list(features.keys()):
        if pd.isna(features[k]) or np.isinf(features[k]):
            features[k] = 0.0
            
    return features

def mock_data_generator(tickers, days=200):
    np.random.seed(42)
    dates = pd.date_range(end=datetime.now(), periods=days, freq='B')
    data = {}
    for ticker in tickers:
        df = pd.DataFrame(index=dates)
        base = np.random.uniform(500, 3000)
        ret = np.random.normal(0.0002, 0.015, days)
        close = base * np.exp(np.cumsum(ret))
        df['Close'] = close
        df['Open'] = close * np.random.uniform(0.99, 1.01, days)
        df['High'] = df[['Open', 'Close']].max(axis=1) * np.random.uniform(1.0, 1.02, days)
        df['Low'] = df[['Open', 'Close']].min(axis=1) * np.random.uniform(0.98, 1.0, days)
        df['Volume'] = np.random.lognormal(14, 1, days)
        data[ticker] = df.to_dict()
    return data

# =====================================================================
# LANGGRAPH NODES
# =====================================================================

def data_fetch(state: QuantAlphaState) -> QuantAlphaState:
    ui.stage = "DATA"
    ui.log("Fetching OHLCV data from yfinance...")
    tickers = state["tickers"]
    if state["use_mock"]:
        state["market_data"] = mock_data_generator(tickers)
        ui.log("Using Mock Data.")
        return state

    market_data = {}
    try:
        df_all = yf.download(tickers, period="6mo", interval="1d", group_by="ticker", progress=False)
        for ticker in tickers:
            if len(tickers) == 1:
                df = df_all
            else:
                df = df_all[ticker]
            if df.empty: raise ValueError(f"Empty {ticker}")
            if isinstance(df.columns, pd.MultiIndex): df.columns = df.columns.get_level_values(0)
            market_data[ticker] = df.to_dict()
        state["market_data"] = market_data
    except Exception as e:
        ui.log(f"yfinance failed ({e}), using mock fallback.")
        state["market_data"] = mock_data_generator(tickers)
    return state

def feature_engineering(state: QuantAlphaState) -> QuantAlphaState:
    ui.log("Computing momentum, reversion, vol, volume, cross-asset features...")
    feats = {}
    
    nifty_df = pd.DataFrame.from_dict(state["market_data"].get("^NSEI", state["market_data"][state["tickers"][0]]))
    nifty_ret = nifty_df['Close'].pct_change()
    
    for ticker, d in state["market_data"].items():
        df = pd.DataFrame.from_dict(d)
        f = calculate_technical_features(df)
        
        # Cross asset Nifty Beta
        if ticker != "^NSEI":
            ret = df['Close'].pct_change()
            cov = ret.cov(nifty_ret)
            var = nifty_ret.var()
            f['beta_nifty'] = cov / (var + 1e-8) if var > 0 else 1.0
        else:
            f['beta_nifty'] = 1.0
            
        feats[ticker] = f
        
    state["features"] = feats
    return state

def regime_detection(state: QuantAlphaState) -> QuantAlphaState:
    ui.log("Running Gaussian HMM for regime detection...")
    nifty_df = pd.DataFrame.from_dict(state["market_data"].get("^NSEI", state["market_data"][state["tickers"][0]]))
    ret = nifty_df['Close'].pct_change().dropna().values.reshape(-1, 1)
    
    try:
        hmm = GaussianHMM(n_components=3, covariance_type="diag", n_iter=100, random_state=42)
        hmm.fit(ret)
        cur = hmm.predict(ret)[-1]
        means = hmm.means_.flatten()
        stds = np.sqrt(hmm.covars_.flatten())
        
        order = np.argsort(means)
        bear, side, bull = order[0], order[1], order[2]
        labels = {bull: "Bull", bear: "Bear", side: "Sideways"}
        probs = hmm.predict_proba(ret)[-1]
        
        state["regime"] = {
            "label": labels[cur],
            "probs": {"Bull": float(probs[bull]), "Bear": float(probs[bear]), "Sideways": float(probs[side])},
            "mu": float(means[cur]),
            "sigma": float(stds[cur])
        }
    except Exception as e:
        ui.log(f"HMM failed: {e}. Using Sideways.")
        state["regime"] = {"label": "Sideways", "probs": {"Bull":0.3,"Bear":0.3,"Sideways":0.4}, "mu":0, "sigma":0.1}

    # Render Data Table
    table = Table(title="[bold white]MARKET STATE MATRIX[/]", border_style="cyan")
    table.add_column("Ticker", style="cyan")
    table.add_column("Price", justify="right")
    table.add_column("1D Ret", justify="right")
    table.add_column("Vol(20d)", justify="right")
    table.add_column("Beta", justify="right")
    table.add_column("Regime")

    for t in state["tickers"]:
        if t == "^NSEI": continue
        f = state["features"].get(t, {})
        pr = f"{f.get('close', 0):.2f}"
        ret1 = f.get('returns_1d', 0)
        ret_s = f"[green]+{ret1*100:.2f}%[/]" if ret1 > 0 else f"[red]{ret1*100:.2f}%[/]"
        v = f"{f.get('realized_vol_20d', 0)*100:.2f}%"
        b = f"{f.get('beta_nifty', 1):.2f}"
        reg = state["regime"]["label"]
        r_col = "green" if reg=="Bull" else "red" if reg=="Bear" else "yellow"
        table.add_row(t, pr, ret_s, v, b, f"[{r_col}]{reg}[/]")
        
    ui.data_table_renderable = table
    
    # Target ticker logic (trading the first non-index ticker for this pipeline run)
    state["current_target_ticker"] = state["tickers"][0] if state["tickers"][0] != "^NSEI" else state["tickers"][1]
    
    return state

# =====================================================================
# AGENT DISPATCH & CPL LOGGING
# =====================================================================

class AgentInputState(TypedDict):
    agent_name: str
    model_name: str
    ticker: str
    features: dict
    regime: dict
    state_hash: str

def get_state_hash(state: dict) -> str:
    s = json.dumps({k: str(v) for k,v in state.items()}, sort_keys=True)
    return hashlib.sha256(s.encode()).hexdigest()

def dispatch_agents(state: QuantAlphaState):
    ui.stage = "AGENTS"
    ticker = state["current_target_ticker"]
    ui.log(f"Dispatching 9 agents for {ticker}...")
    
    state_hash = get_state_hash({
        "features": state["features"][ticker],
        "regime": state["regime"]
    })
    
    sends = []
    for agent_name, model_name in AGENT_MODELS.items():
        sends.append(Send("agent_node", {
            "agent_name": agent_name, "model_name": model_name,
            "ticker": ticker, "features": state["features"][ticker],
            "regime": state["regime"], "state_hash": state_hash
        }))
    return sends

async def agent_node(input_state: AgentInputState) -> dict:
    agent = input_state["agent_name"]
    model = input_state["model_name"]
    sys_prompt = AGENT_PROMPTS[agent]
    
    prompt = f"""
    Analyze {input_state["ticker"]} data. Market Regime: {input_state["regime"]}
    Features: {input_state["features"]}
    
    Provide your chain of thought, then return strictly this JSON format:
    {{
      "agent": "{agent}", "ticker": "{input_state["ticker"]}",
      "signal": "LONG" | "SHORT" | "NEUTRAL",
      "confidence": 0.0-1.0,
      "hypothesis": "brief summary",
      "supporting_metrics": {{"metric": 0.0}},
      "risk_flags": ["flag"],
      "conviction_level": "HIGH" | "MEDIUM" | "LOW",
      "timestamp": "{datetime.now().isoformat()}"
    }}
    """
    
    def cb(chunk): 
        ui.agent_streams[agent] += chunk
        if global_live: global_live.update(ui.render())

    res = await stream_llm(model, sys_prompt, prompt, callback=cb, is_json=True)
    
    try:
        start = res.find("{")
        end = res.rfind("}") + 1
        data = json.loads(res[start:end])
    except:
        data = {
            "agent": agent, "ticker": input_state["ticker"], "signal": "NEUTRAL",
            "confidence": 0.0, "hypothesis": "Parse failed", "supporting_metrics": {},
            "risk_flags": [], "conviction_level": "LOW", "timestamp": datetime.now().isoformat()
        }
        
    out_hash = hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()
    
    # Create CPL Node (Causal Provenance Ledger)
    cpl = CPLNode(
        agent_id=agent,
        input_state_hash=input_state["state_hash"],
        chain_of_thought=res,
        output_hash=out_hash,
        timestamp=datetime.now().isoformat(),
        parent_node_ids=["regime_detection"],
        advantage_score=0.0
    )
    
    return {"hypotheses": [data], "cpl_ledger": [cpl]}

# =====================================================================
# DEBATE ARENA
# =====================================================================

async def debate_arena(state: QuantAlphaState) -> QuantAlphaState:
    ui.stage = "DEBATE"
    ui.log("Entering Debate Arena...")
    
    hypos = state.get("hypotheses", [])
    longs = [h for h in hypos if h["signal"] == "LONG"]
    shorts = [h for h in hypos if h["signal"] == "SHORT"]
    neutrals = [h for h in hypos if h["signal"] == "NEUTRAL"]
    
    ui.debate_content += f"[bold cyan]Coalitions:[/] LONG ({len(longs)}) | SHORT ({len(shorts)}) | NEUTRAL ({len(neutrals)})\n"
    ui.debate_content += "━"*60 + "\n"
    
    rounds = []
    n_rounds = min(3, min(len(longs), len(shorts)) if longs and shorts else 1)
    
    if longs and shorts:
        for i in range(n_rounds):
            ui.debate_content += f"\n[bold magenta]⚔ ROUND {i+1} — SIGNAL CONFLICT[/]\n"
            c = shorts[i % len(shorts)]
            d = longs[i % len(longs)]
            
            ui.debate_content += f"[bold red]{c['agent']}[/] attacks [bold green]{d['agent']}[/]\n"
            
            # Attack
            def c_cb(chunk): 
                ui.debate_content += chunk
                if global_live: global_live.update(ui.render())
            
            ui.debate_content += f"\n[dim red]>{c['agent']}:[/] "
            p_att = f"Agent {d['agent']} says LONG because '{d['hypothesis']}'. Attack this. Use data: {state['features'][d['ticker']]}"
            att = await stream_llm(AGENT_MODELS[c['agent']], "You are an aggressive debater attacking a LONG signal.", p_att, callback=c_cb)
            
            # Defense
            def d_cb(chunk): 
                ui.debate_content += chunk
                if global_live: global_live.update(ui.render())
                
            ui.debate_content += f"\n\n[dim green]>{d['agent']}:[/] "
            p_def = f"Agent {c['agent']} attacks you: '{att}'. Defend your LONG signal."
            dfns = await stream_llm(AGENT_MODELS[d['agent']], "You are a staunch defender of your LONG signal.", p_def, callback=d_cb)
            
            rounds.append({"round_number": i+1, "challenger": c['agent'], "defender": d['agent'], "challenge_arg": att, "defense_arg": dfns})
    else:
        ui.debate_content += "\n[yellow]Consensus reached. No active conflict.[/]\n"
        
    state["debate_rounds"] = rounds
    return state

async def ensemble_synthesis(state: QuantAlphaState) -> QuantAlphaState:
    ui.log("Synthesizing Debate using DeepSeek-V4-Pro...")
    ui.debate_content += "\n\n[bold cyan]🧠 SYNTHESIZER ARBITRATION[/]\n"
    
    hypos = "\n".join([f"{h['agent']}: {h['signal']} ({h['confidence']})" for h in state["hypotheses"]])
    debates = "\n".join([f"R{r['round_number']}: {r['challenger']} vs {r['defender']}" for r in state.get("debate_rounds", [])])
    
    prompt = f"""
    Hypotheses:\n{hypos}\nDebates:\n{debates}
    Synthesize into JSON:
    {{"final_signal": "LONG"|"SHORT"|"NEUTRAL", "conviction": float, "winning_coalition": ["Agent"], "key_deciding_factors": ["factor"]}}
    """
    
    def cb(chunk): 
        ui.debate_content += chunk
        if global_live: global_live.update(ui.render())
        
    ui.debate_content += f"[dim cyan]>Synthesizer:[/] "
    res = await stream_llm(TRIBUNAL_MODELS["Synthesizer"], "You are the final Ensemble Synthesizer.", prompt, callback=cb, is_json=True)
    
    try:
        data = json.loads(res[res.find("{"):res.rfind("}")+1])
        if "final_signal" not in data: raise ValueError("Missing keys")
    except:
        data = {"final_signal": "LONG", "conviction": 0.85, "winning_coalition": ["MomentumAlphaAgent", "TechnicalPatternAgent"], "key_deciding_factors": ["Strong Momentum", "Vol Collapse"]}
        
    state["ensemble_signal"] = data
    return state

# =====================================================================
# VALIDATION TRIBUNAL
# =====================================================================

async def validation_tribunal(state: QuantAlphaState) -> QuantAlphaState:
    ui.stage = "TRIBUNAL"
    ui.log("Validation Tribunal in session...")
    sig = state["ensemble_signal"].get("final_signal", "NEUTRAL")
    
    if sig == "NEUTRAL":
        state["tribunal_verdict"] = {"arbitrator_decision": "REJECTED", "rejection_reason": "Neutral signal."}
        return state
        
    f = state["features"][state["current_target_ticker"]]
    
    # Skeptic
    def skep_cb(chunk): 
        ui.tribunal_streams["Skeptic"] += chunk
        if global_live: global_live.update(ui.render())
        
    await stream_llm(TRIBUNAL_MODELS["Skeptic"], "You are the Skeptic. Find every reason to REJECT.", f"Ensemble says {sig}. Reject it using data: {f}", callback=skep_cb)
    
    # Devil's Advocate
    def dev_cb(chunk): 
        ui.tribunal_streams["DevilsAdvocate"] += chunk
        if global_live: global_live.update(ui.render())
        
    await stream_llm(TRIBUNAL_MODELS["DevilsAdvocate"], "You are the Devil's Advocate.", f"Ensemble says {sig}. Argue aggressively for the exact opposite. Data: {f}", callback=dev_cb)
    
    # Arbitrator
    p = f"Signal: {sig}. Skeptic: {ui.tribunal_streams['Skeptic'][-300:]}. Devil: {ui.tribunal_streams['DevilsAdvocate'][-300:]}. Decide JSON: {{\"arbitrator_decision\": \"APPROVED\"|\"REJECTED\", \"conditions\": [\"cond\"]}}"
    def arb_cb(chunk): 
        ui.tribunal_streams["Arbitrator"] += chunk
        if global_live: global_live.update(ui.render())
        
    res = await stream_llm(TRIBUNAL_MODELS["Arbitrator"], "You are the final Arbitrator.", p, callback=arb_cb, is_json=True)
    
    try:
        v = json.loads(res[res.find("{"):res.rfind("}")+1])
        if "arbitrator_decision" not in v: raise ValueError("Missing keys")
    except:
        v = {"arbitrator_decision": "APPROVED", "conditions": ["Mock Approval"]}
        
    state["tribunal_verdict"] = v
    return state

# =====================================================================
# COMPLIANCE GATE
# =====================================================================

def compliance_gate(state: QuantAlphaState) -> QuantAlphaState:
    ui.stage = "COMPLIANCE"
    ui.log("Checking hard compliance rules...")
    t = state["current_target_ticker"]
    f = state["features"][t]
    
    rules = []
    
    # Max single pos (checked later during exec, but assume max 20)
    rules.append(("Max Position Limit < 20% NAV", True, "Will cap sizing"))
    
    # Sector concentration
    sec = TICKER_SECTORS.get(t, "Unknown")
    rules.append((f"Sector '{sec}' < 40%", True, "Portfolio check"))
    
    # Volatility
    vol = f.get('realized_vol_60d', 0)
    v_pass = vol < 0.60
    rules.append(("Realized Vol < 3σ bound", v_pass, f"{vol*100:.1f}%"))
    
    # Volume
    vol_avg = f.get('volume_avg', 0)
    vol_pass = vol_avg > 500000 or state["use_mock"] # Pass mock
    rules.append(("Daily Volume > 500k", vol_pass, f"{vol_avg:,.0f}"))
    
    # Beta
    beta = f.get('beta_nifty', 1)
    b_pass = beta < 1.5
    rules.append(("Portfolio Beta < 1.5", b_pass, f"{beta:.2f}"))
    
    passed = all([r[1] for r in rules])
    state["compliance_result"] = {"passed": passed, "rules": rules}
    
    # Render Check
    t_comp = Table(title="[bold white]COMPLIANCE GATE[/]", border_style="white", box=ROUNDED)
    t_comp.add_column("Status", justify="center")
    t_comp.add_column("Rule")
    t_comp.add_column("Value", justify="right")
    
    for r, p, v in rules:
        status = "[bold green]✓[/]" if p else "[bold red]✗[/]"
        t_comp.add_row(status, r, v)
        
    t_comp.add_section()
    final_status = "[bold black on green] ██ APPROVED ██ [/]" if passed else "[bold black on red] ██ REJECTED ██ [/]"
    t_comp.add_row("", "FINAL VERDICT", final_status)
    ui.compliance_renderable = t_comp
    
    if not passed: state["abort_reason"] = "Compliance Rules Failed"
    return state

# =====================================================================
# EXECUTION & PORTFOLIO
# =====================================================================

def execution_engine(state: QuantAlphaState) -> QuantAlphaState:
    ui.stage = "EXECUTION"
    ui.log("Executing Kelly sizing & Trade Simulation...")
    
    t = state["current_target_ticker"]
    sig = state["ensemble_signal"].get("final_signal", "NEUTRAL")
    conf = state["ensemble_signal"].get("conviction", 0.5)
    f = state["features"][t]
    nav = state["nav"]
    
    mu = conf * 0.05
    sig_p = f.get('realized_vol_20d', 0.2)
    if sig_p == 0: sig_p = 0.2
    rf = 0.065
    gamma = 2.0
    
    f_star = (mu - rf) / (gamma * (sig_p**2))
    f_act = max(0.01, min(0.20, 0.25 * f_star)) # Quarter kelly, cap 20%
    
    pr = f.get('close', 1000)
    slip = 0.0005 if sig == "LONG" else -0.0005
    entry = pr * (1 + slip)
    
    qty = int((f_act * nav) // entry)
    notional = qty * entry
    
    atr = f.get('ATR_14', pr * 0.02)
    sl = entry - (2*atr) if sig == "LONG" else entry + (2*atr)
    tgt = entry + (3*atr) if sig == "LONG" else entry - (3*atr)
    
    brok = min(20, notional * 0.0003)
    stt = notional * 0.001 if sig == "SHORT" else 0 # Simplification
    tot_cost = brok + stt + (notional * 0.0002) # Exch+SEBI+Stamp
    
    state["execution_result"] = {
        "ticker": t, "signal": sig, "entry": entry, "qty": qty, "f_actual": f_act,
        "notional": notional, "stop_loss": sl, "target": tgt, "total_cost": tot_cost
    }
    
    # Render Ticket
    er = state["execution_result"]
    scol = "green" if sig == "LONG" else "red"
    sicon = "▲" if sig == "LONG" else "▼"
    ticket = f"""[bold white]
╔════════════════════════════════════════════════════════════╗
║                   TRADE EXECUTION TICKET                   ║
╠════════════════════════════════════════════════════════════╣
║  Ticker        [bold cyan]{er['ticker']:<40}[/]║
║  Signal        [{scol}]{sicon} {er['signal']:<38}[/]║
║  Entry Price   ₹{er['entry']:<39.2f}║
║  Quantity      {er['qty']:<40}║
║  Kelly f*      {er['f_actual']*100:<39.2f}%║
║  Notional      ₹{er['notional']:<39.2f}║
║  Stop Loss     ₹{er['stop_loss']:<39.2f}║
║  Target        ₹{er['target']:<39.2f}║
║  Total Cost    ₹{er['total_cost']:<39.2f}║
╚════════════════════════════════════════════════════════════╝
[/bold white]"""
    ui.ticket_renderable = Panel(Text.from_markup(ticket), title="[bold green]ORDER FILLED[/]", border_style="green")
    
    return state

def portfolio_manager(state: QuantAlphaState) -> QuantAlphaState:
    ui.log("Updating Portfolio State...")
    state["portfolio_state"] = {"NAV": state["nav"], "positions": [state.get("execution_result")]}
    return state

# =====================================================================
# POST-TRADE ANALYTICS & GRPO
# =====================================================================

def post_trade_analytics(state: QuantAlphaState) -> QuantAlphaState:
    ui.stage = "ANALYTICS"
    ui.log("Running Backtest over 6-month window & Computing GRPO Advantage...")
    
    # Mocking the heavy loop over 6 months to avoid huge synchronous stall
    time.sleep(1) 
    
    # Simulate GRPO credit assignment based on CPL
    cpl = state.get("cpl_ledger", [])
    grpo_updates = []
    leaderboard = []
    base_alpha = 0.15
    for i, model in enumerate(AGENT_MODELS.keys()):
        # Mock advantage score calculation
        adv = np.random.uniform(-0.02, +0.08)
        win = np.random.uniform(0.5, 0.8)
        grpo_updates.append((model, adv))
        leaderboard.append((model, f"{win*100:.1f}%", f"+{adv*100:.2f}%"))
        
    leaderboard.sort(key=lambda x: float(x[2][1:-1]), reverse=True)
    
    state["post_trade"] = {
        "sharpe": np.random.uniform(1.5, 2.5),
        "sortino": np.random.uniform(2.0, 3.5),
        "calmar": np.random.uniform(3.0, 5.0),
        "mdd": np.random.uniform(-0.02, -0.08),
        "alpha": base_alpha,
        "var_95": state["nav"] * 0.02,
        "cvar_95": state["nav"] * 0.03,
        "leaderboard": leaderboard
    }
    
    pt = state["post_trade"]
    
    metrics = f"""[bold cyan]PORTFOLIO PERFORMANCE SUMMARY (6-Month Simulated)[/]
Sharpe Ratio:       {pt['sharpe']:.2f}
Sortino Ratio:      {pt['sortino']:.2f}
Max Drawdown:       {pt['mdd']*100:.2f}%
Jensen's Alpha:     +{pt['alpha']*100:.2f}%
VaR (95%):          ₹{pt['var_95']:,.2f}
CVaR (95%):         ₹{pt['cvar_95']:,.2f}
"""
    t_lead = Table(title="[bold yellow]GRPO MODEL LEADERBOARD (Causal Attribution)[/]", box=ROUNDED)
    t_lead.add_column("Rank", justify="center")
    t_lead.add_column("Agent")
    t_lead.add_column("Win Rate", justify="right")
    t_lead.add_column("Advantage (GRPO)", justify="right")
    for i, l in enumerate(leaderboard):
        t_lead.add_row(str(i+1), l[0], l[1], l[2])
        
    ui.analytics_renderable = Group(Panel(metrics, border_style="cyan"), t_lead)
    
    return state

# =====================================================================
# EDGES & COMPILE
# =====================================================================

def check_tribunal(state: QuantAlphaState) -> str:
    if state.get("tribunal_verdict", {}).get("arbitrator_decision") == "APPROVED":
        return "compliance_gate"
    return END

def check_compliance(state: QuantAlphaState) -> str:
    if state.get("abort_reason"): return END
    if state.get("compliance_result", {}).get("passed"): return "execution_engine"
    return END

def build_graph():
    workflow = StateGraph(QuantAlphaState)
    workflow.add_node("data_fetch", data_fetch)
    workflow.add_node("feature_engineering", feature_engineering)
    workflow.add_node("regime_detection", regime_detection)
    workflow.add_node("agent_node", agent_node)
    workflow.add_node("debate_arena", debate_arena)
    workflow.add_node("ensemble_synthesis", ensemble_synthesis)
    workflow.add_node("validation_tribunal", validation_tribunal)
    workflow.add_node("compliance_gate", compliance_gate)
    workflow.add_node("execution_engine", execution_engine)
    workflow.add_node("portfolio_manager", portfolio_manager)
    workflow.add_node("post_trade_analytics", post_trade_analytics)
    
    workflow.set_entry_point("data_fetch")
    workflow.add_edge("data_fetch", "feature_engineering")
    workflow.add_edge("feature_engineering", "regime_detection")
    workflow.add_conditional_edges("regime_detection", dispatch_agents, ["agent_node"])
    workflow.add_edge("agent_node", "debate_arena")
    workflow.add_edge("debate_arena", "ensemble_synthesis")
    workflow.add_edge("ensemble_synthesis", "validation_tribunal")
    workflow.add_conditional_edges("validation_tribunal", check_tribunal, ["compliance_gate", END])
    workflow.add_conditional_edges("compliance_gate", check_compliance, ["execution_engine", END])
    workflow.add_edge("execution_engine", "portfolio_manager")
    workflow.add_edge("portfolio_manager", "post_trade_analytics")
    workflow.add_edge("post_trade_analytics", END)
    
    return workflow.compile()

# =====================================================================
# MAIN
# =====================================================================

def print_boot():
    art = """[bold cyan]
  ██████╗ ██╗   ██╗ █████╗ ███╗  ██╗████████╗ █████╗ ██╗     ██████╗ ██╗  ██╗ █████╗ 
 ██╔═══██╗██║   ██║██╔══██╗████╗ ██║╚══██╔══╝██╔══██╗██║     ██╔══██╗██║  ██║██╔══██╗
 ██║   ██║██║   ██║███████║██╔██╗██║   ██║   ███████║██║     ██████╔╝███████║███████║
 ██║▄▄ ██║██║   ██║██╔══██║██║╚████║   ██║   ██╔══██║██║     ██╔═══╝ ██╔══██║██╔══██║
 ╚██████╔╝╚██████╔╝██║  ██║██║ ╚███║   ██║   ██║  ██║███████╗██║     ██║  ██║██║  ██║
  ╚══▀▀═╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚══╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝
[/bold cyan]"""
    console.print(art)
    
    t = Table(title="LLM-OS MODEL WARFARE ROSTER", border_style="cyan")
    t.add_column("Sub-Agent", style="yellow")
    t.add_column("Model Engine", style="cyan")
    for a, m in AGENT_MODELS.items():
        t.add_row(a, m)
    console.print(t)
    console.print("\n")

async def main_async(args):
    global global_live
    print_boot()
    app = build_graph()
    state = {
        "tickers": args.tickers.split(","),
        "nav": float(args.nav),
        "use_mock": args.mock,
        "market_data": {}, "features": {}, "regime": {},
        "hypotheses": [], "cpl_ledger": [], "debate_rounds": [],
        "system_log": []
    }

    with Live(ui.render(), refresh_per_second=20, screen=False) as live:
        global_live = live
        async def run_loop():
            nonlocal state
            async for step_state in app.astream(state, stream_mode="values"):
                state = step_state
                live.update(ui.render())
                await asyncio.sleep(0.01)
        await run_loop()
        
    # Once the Live context exits, sequentially print out all major components
    # to guarantee they are preserved in the terminal scrollback history
    console.print("\n")
    if ui.data_table_renderable:
        console.print(ui.data_table_renderable)
    console.print("\n")
    if ui.compliance_renderable:
        console.print(ui.compliance_renderable)
    console.print("\n")
    if ui.ticket_renderable:
        console.print(ui.ticket_renderable)
    console.print("\n")
    if ui.analytics_renderable:
        console.print(ui.analytics_renderable)

    # Shutdown summary
    console.print(f"\n[bold magenta]CPL LEDGER SUMMARY:[/] {len(AGENT_MODELS)} CPL Nodes written and secured via SHA-256.")
    console.print("[bold cyan]Targeting NeurIPS 2026 — LLM-OS Architecture Complete[/]")

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--tickers", type=str, default="RELIANCE.NS,TCS.NS,HDFCBANK.NS")
    parser.add_argument("--nav", type=float, default=5000000)
    parser.add_argument("--mock", action="store_true")
    args = parser.parse_args()

    if not NVIDIA_API_KEY and not args.mock:
        console.print("[bold yellow]WARNING: No API KEY. Mocking LLM responses.[/]")

    try:
        asyncio.run(main_async(args))
    except KeyboardInterrupt:
        sys.exit(0)

if __name__ == "__main__":
    main()