Convert to HuggingFace Docker SDK with Streamlit - Add src/streamlit_app.py (1278 lines) - full Streamlit conversion - Add Dockerfile for HF Docker SDK deployment - Update requirements.txt with version constraints - Update README.md with sdk: docker - Remove Super Saiyan branding from main.py - Delete old app.py (replaced by src/streamlit_app.py)

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    stockfish \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . .
+
+EXPOSE 7860
+
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -3,8 +3,7 @@ title: Cascade Lattice Chess
 emoji: ♟️
 colorFrom: blue
 colorTo: purple
-sdk: streamlit
-sdk_version: 1.41.0
+sdk: docker
 app_file: app.py
 pinned: false
 license: mit

app.py

@@ -1,914 +0,0 @@
-import streamlit as st
-import chess
-import chess.engine
-import chess.svg
-import os
-import random
-import time
-import math
-import hashlib
-from collections import deque
-from dataclasses import dataclass, field
-from typing import List, Dict, Any, Optional, Tuple
-
-# Conditional imports
-try:
-    import torch
-    from transformers import AutoModel
-    TORCH_AVAILABLE = True
-except ImportError:
-    TORCH_AVAILABLE = False
-    print("[WARNING] PyTorch not available")
-
-try:
-    import cascade
-    CASCADE_AVAILABLE = True
-except ImportError:
-    CASCADE_AVAILABLE = False
-    print("[WARNING] cascade-lattice not available, using mocks")
-
-# Configuration
-MODEL_NAME = "Maxlegrec/ChessBot"
-
-def find_stockfish():
-    paths = [
-        "/usr/games/stockfish",
-        "/usr/bin/stockfish",
-        "/usr/local/bin/stockfish",
-        "stockfish/stockfish-windows-x86-64-avx2.exe",
-        "stockfish/stockfish"
-    ]
-    for p in paths:
-        if os.path.exists(p):
-            return p
-    return None
-
-STOCKFISH_PATH = find_stockfish()
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# CASCADE MOCK (when cascade-lattice isn't available)
-# ═══════════════════════════════════════════════════════════════════════════════
-
-class MockHold:
-    _instance = None
-    def __init__(self):
-        self.timeout = 3600
-        self.listeners = []
-    @classmethod
-    def get(cls):
-        if cls._instance is None:
-            cls._instance = MockHold()
-        return cls._instance
-    def register_listener(self, fn):
-        self.listeners.append(fn)
-    def resolve(self, action=None):
-        pass
-
-class MockCausationGraph:
-    def __init__(self):
-        self.events = []
-        self.links = []
-    def add_event(self, e): self.events.append(e)
-    def add_link(self, l): self.links.append(l)
-    def get_stats(self): return {'events': len(self.events), 'links': len(self.links)}
-
-class MockMetricsEngine:
-    def __init__(self): self.metrics = {}
-    def ingest(self, e): pass
-    def summary(self): return {}
-
-class MockEvent:
-    def __init__(self, **kwargs):
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-class MockCausationLink:
-    def __init__(self, **kwargs):
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-if CASCADE_AVAILABLE:
-    CascadeHold = cascade.Hold
-    CausationGraph = cascade.CausationGraph
-    MetricsEngine = cascade.MetricsEngine
-    CascadeEvent = cascade.Event
-    CausationLink = cascade.CausationLink
-    cascade.init()
-else:
-    CascadeHold = MockHold
-    CausationGraph = MockCausationGraph
-    MetricsEngine = MockMetricsEngine
-    CascadeEvent = MockEvent
-    CausationLink = MockCausationLink
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# DATA CLASSES
-# ═══════════════════════════════════════════════════════════════════════════════
-
-@dataclass
-class CausalNode:
-    event_id: str
-    move: str
-    player: str
-    fen: str
-    timestamp: float
-    merkle: str
-    value: float
-    was_override: bool = False
-    depth: int = 0
-
-@dataclass
-class PredictionRisk:
-    move: str
-    risk_score: float
-    predicted_responses: List[str]
-    material_delta: int
-    positional_delta: float
-    tactical_threats: List[str]
-    intervention_point: bool = False
-
-@dataclass
-class AnomalyAlert:
-    timestamp: float
-    metric_name: str
-    expected_value: float
-    actual_value: float
-    deviation_sigma: float
-    severity: str
-    message: str
-
-@dataclass
-class SessionStats:
-    total_holds: int = 0
-    human_overrides: int = 0
-    ai_accepted: int = 0
-    current_combo: int = 0
-    max_combo: int = 0
-    override_rate: float = 0.0
-    avg_decision_time: float = 0.0
-    decision_times: List[float] = field(default_factory=list)
-    speed_bonus: float = 0.0
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# GAME STATE CLASS
-# ═══════════════════════════════════════════════════════════════════════════════
-
-class ChessGameState:
-    def __init__(self):
-        self.reset_game()
-        self.causation_graph = CausationGraph()
-        self.metrics_engine = MetricsEngine()
-        self.causal_chain: List[CausalNode] = []
-        self.merkle_chain: List[str] = []
-        self.last_event_id = None
-        self.model = None
-        self.device = "cpu"
-        self.engine = None
-        self.auto_mode = False
-        self.anomalies: deque = deque(maxlen=50)
-        self.value_history: List[float] = []
-        self.hold_start_time: Optional[float] = None
-        
-    def reset_game(self):
-        self.board = chess.Board()
-        self.move_history = []
-        self.session = SessionStats()
-        self.candidates = []
-        self.predictions = []
-        self.selected_idx = 0
-        self.ui_mode = "LIST"
-        self.active_tab = "WEALTH"
-        self.game_over = False
-        self.game_result = ""
-        self.hold_active = False
-        self.current_merkle = ""
-        self.last_observation = {}
-        
-    def load_model(self):
-        if not TORCH_AVAILABLE or self.model is not None:
-            return
-        try:
-            self.model = AutoModel.from_pretrained(MODEL_NAME, trust_remote_code=True)
-            self.device = "cuda" if torch.cuda.is_available() else "cpu"
-            self.model.to(self.device)
-            self.model.eval()
-            st.success(f"Model loaded on {self.device}")
-        except Exception as e:
-            st.error(f"Model load failed: {e}")
-            
-    def init_engine(self):
-        if STOCKFISH_PATH and self.engine is None:
-            try:
-                self.engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
-            except Exception as e:
-                st.warning(f"Stockfish init failed: {e}")
-                
-    def _compute_merkle(self, data: Dict) -> str:
-        content = str(sorted(data.items())).encode()
-        return hashlib.sha256(content).hexdigest()[:16]
-    
-    def register_event(self, event_data: Dict) -> str:
-        event_id = f"evt_{len(self.causal_chain)}_{int(time.time()*1000)}"
-        
-        if CASCADE_AVAILABLE:
-            event = CascadeEvent(
-                event_id=event_id,
-                timestamp=time.time(),
-                component=event_data.get('player', 'chess'),
-                event_type=event_data.get('type', 'move'),
-                data=event_data
-            )
-            self.causation_graph.add_event(event)
-            
-            if self.last_event_id and self.causal_chain:
-                link = CausationLink(
-                    from_event=self.last_event_id,
-                    to_event=event_id,
-                    causation_type="game_sequence",
-                    strength=1.0,
-                    explanation=f"Move sequence"
-                )
-                self.causation_graph.add_link(link)
-        
-        node = CausalNode(
-            event_id=event_id,
-            move=event_data.get('move', ''),
-            player=event_data.get('player', ''),
-            fen=event_data.get('fen', ''),
-            timestamp=time.time(),
-            merkle=self._compute_merkle(event_data),
-            value=event_data.get('value', 0.0),
-            was_override=event_data.get('was_override', False),
-            depth=len(self.causal_chain)
-        )
-        
-        self.causal_chain.append(node)
-        self.merkle_chain.append(node.merkle)
-        self.last_event_id = event_id
-        return event_id
-    
-    def get_ai_move(self) -> Tuple[Optional[str], List[Dict], float]:
-        fen = self.board.fen()
-        legal_moves = [m.uci() for m in self.board.legal_moves]
-        
-        if not legal_moves:
-            return None, [], 0.0
-        
-        move_uci = None
-        pos_eval = [0.33, 0.34, 0.33]
-        
-        if self.model is not None:
-            try:
-                with torch.no_grad():
-                    pos_eval = self.model.get_position_value(fen, device=self.device).tolist()
-                    move_uci = self.model.get_move_from_fen_no_thinking(fen, T=0.1, device=self.device)
-            except Exception as e:
-                st.warning(f"AI error: {e}")
-        
-        if move_uci is None or move_uci not in legal_moves:
-            move_uci = random.choice(legal_moves)
-        
-        candidates = [{
-            "move": move_uci,
-            "prob": 0.82,
-            "v_head": pos_eval,
-            "reason": "Primary engine recommendation"
-        }]
-        
-        others = [m for m in legal_moves if m != move_uci]
-        random.shuffle(others)
-        for i, m in enumerate(others[:4]):
-            v_noise = [v + random.uniform(-0.08, 0.08) for v in pos_eval]
-            candidates.append({
-                "move": m,
-                "prob": max(0.01, 0.15 - i * 0.03),
-                "v_head": v_noise,
-                "reason": self._generate_move_reason(m)
-            })
-        
-        value = pos_eval[2] - pos_eval[0]
-        return move_uci, candidates, value
-    
-    def _generate_move_reason(self, move_uci: str) -> str:
-        reasons = [
-            "Develops piece activity",
-            "Controls central squares", 
-            "Prepares kingside operation",
-            "Maintains pawn structure",
-            "Creates tactical threats",
-            "Improves piece coordination"
-        ]
-        try:
-            move = chess.Move.from_uci(move_uci)
-            piece = self.board.piece_at(move.from_square)
-            if piece:
-                if self.board.is_capture(move):
-                    return f"{chess.piece_name(piece.piece_type).capitalize()} capture"
-                elif piece.piece_type == chess.PAWN:
-                    return "Pawn advance - space control"
-        except:
-            pass
-        return random.choice(reasons)
-    
-    def get_stockfish_move(self) -> str:
-        if self.engine:
-            try:
-                result = self.engine.play(self.board, chess.engine.Limit(time=0.5))
-                return result.move.uci()
-            except:
-                pass
-        return random.choice([m.uci() for m in self.board.legal_moves])
-    
-    def predict_cascade(self, candidates: List[Dict]) -> List[PredictionRisk]:
-        predictions = []
-        for c in candidates:
-            try:
-                move = chess.Move.from_uci(c['move'])
-                temp = self.board.copy()
-                mat_before = self._count_material(temp)
-                temp.push(move)
-                mat_after = self._count_material(temp)
-                responses = [m.uci() for m in list(temp.legal_moves)[:5]]
-                threats = self._detect_threats(temp, move)
-                
-                risk = 0.0
-                mat_delta = mat_after - mat_before
-                if mat_delta < 0:
-                    risk += min(0.3, abs(mat_delta) * 0.1)
-                risk += len(threats) * 0.1
-                risk += (1 - c['prob']) * 0.3
-                if temp.is_checkmate():
-                    risk = 0.0
-                elif temp.is_check():
-                    risk += 0.1
-                risk = min(1.0, max(0.0, risk))
-                
-                predictions.append(PredictionRisk(
-                    move=c['move'],
-                    risk_score=risk,
-                    predicted_responses=responses,
-                    material_delta=mat_delta,
-                    positional_delta=c['v_head'][2] - c['v_head'][0],
-                    tactical_threats=threats,
-                    intervention_point=risk > 0.7 or len(threats) > 2
-                ))
-            except:
-                pass
-        return predictions
-    
-    def _detect_threats(self, board: chess.Board, last_move: chess.Move) -> List[str]:
-        threats = []
-        if board.is_check():
-            threats.append("CHECK")
-        for square in chess.SQUARES:
-            piece = board.piece_at(square)
-            if piece and piece.color == board.turn:
-                attackers = board.attackers(not board.turn, square)
-                defenders = board.attackers(board.turn, square)
-                if len(attackers) > len(defenders):
-                    threats.append(f"HANGING_{chess.square_name(square).upper()}")
-        if len(threats) > 1:
-            threats.append("FORK_THREAT")
-        return threats[:5]
-    
-    def _count_material(self, board) -> int:
-        values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3, 
-                  chess.ROOK: 5, chess.QUEEN: 9}
-        score = 0
-        for sq in chess.SQUARES:
-            piece = board.piece_at(sq)
-            if piece and piece.piece_type in values:
-                val = values[piece.piece_type]
-                score += val if piece.color == chess.WHITE else -val
-        return score
-    
-    def check_anomalies(self, current_data: Dict) -> List[AnomalyAlert]:
-        new_anomalies = []
-        if 'confidence' in current_data:
-            conf = current_data['confidence']
-            if conf < 0.3:
-                alert = AnomalyAlert(
-                    timestamp=time.time(),
-                    metric_name="confidence",
-                    expected_value=0.7,
-                    actual_value=conf,
-                    deviation_sigma=2.5,
-                    severity="WARNING",
-                    message=f"Low AI confidence: {conf*100:.1f}%"
-                )
-                new_anomalies.append(alert)
-                self.anomalies.append(alert)
-        return new_anomalies
-    
-    def make_move(self, move_uci: str, player: str, was_override: bool = False):
-        try:
-            move = chess.Move.from_uci(move_uci)
-            if move in self.board.legal_moves:
-                self.board.push(move)
-                
-                value = 0.0
-                if self.model:
-                    try:
-                        with torch.no_grad():
-                            ev = self.model.get_position_value(self.board.fen(), device=self.device)
-                            value = float(ev[2] - ev[0])
-                            self.value_history.append(value)
-                    except:
-                        pass
-                
-                self.move_history.append({
-                    'move': move_uci,
-                    'player': player,
-                    'was_override': was_override
-                })
-                
-                self.register_event({
-                    'type': 'move',
-                    'move': move_uci,
-                    'player': player,
-                    'fen': self.board.fen(),
-                    'value': value,
-                    'was_override': was_override
-                })
-                
-                if was_override:
-                    self.session.human_overrides += 1
-                    self.session.current_combo = 0
-                else:
-                    self.session.ai_accepted += 1
-                    self.session.current_combo += 1
-                    self.session.max_combo = max(self.session.max_combo, self.session.current_combo)
-                
-                self.session.total_holds += 1
-                if self.session.total_holds > 0:
-                    self.session.override_rate = self.session.human_overrides / self.session.total_holds
-                
-                if self.board.is_game_over():
-                    self.game_over = True
-                    result = self.board.result()
-                    if result == "1-0":
-                        self.game_result = "WHITE WINS (ChessBot)"
-                    elif result == "0-1":
-                        self.game_result = "BLACK WINS (Stockfish)"
-                    else:
-                        self.game_result = f"DRAW ({result})"
-                
-                return True
-        except Exception as e:
-            st.error(f"Move error: {e}")
-        return False
-    
-    def start_hold_timer(self):
-        self.hold_start_time = time.time()
-    
-    def get_hold_duration(self) -> float:
-        if self.hold_start_time:
-            return time.time() - self.hold_start_time
-        return 0.0
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# STREAMLIT UI
-# ═══════════════════════════════════════════════════════════════════════════════
-
-st.set_page_config(
-    page_title="CASCADE LATTICE CHESS",
-    page_icon="♟️",
-    layout="wide"
-)
-
-# Custom CSS for dark theme
-st.markdown("""
-<style>
-    .stApp {
-        background-color: #121216;
-    }
-    .metric-card {
-        background-color: #23232d;
-        padding: 15px;
-        border-radius: 8px;
-        margin: 5px 0;
-    }
-    .risk-low { color: #00ff96; }
-    .risk-med { color: #ff9632; }
-    .risk-high { color: #ff4646; }
-    .merkle-hash { 
-        font-family: monospace; 
-        color: #64ffda;
-        background: #1a2a2f;
-        padding: 2px 6px;
-        border-radius: 3px;
-    }
-    .candidate-card {
-        background: #2d2d3a;
-        padding: 12px;
-        border-radius: 6px;
-        margin: 8px 0;
-        border-left: 3px solid #00c8ff;
-    }
-    .candidate-card:hover {
-        background: #3d3d4a;
-    }
-    .override-card {
-        border-left-color: #ffa500;
-    }
-    .combo-display {
-        font-size: 24px;
-        color: #ffd700;
-        font-weight: bold;
-    }
-    .threat-badge {
-        background: #ff4646;
-        color: white;
-        padding: 2px 8px;
-        border-radius: 4px;
-        font-size: 12px;
-    }
-    .tab-active {
-        background: #00c8ff;
-        color: black;
-        padding: 8px 16px;
-        border-radius: 4px;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize session state
-if 'game_state' not in st.session_state:
-    st.session_state.game_state = ChessGameState()
-    st.session_state.initialized = False
-
-gs = st.session_state.game_state
-
-# Initialize on first run
-if not st.session_state.initialized:
-    with st.spinner("Loading ChessBot model..."):
-        gs.load_model()
-    gs.init_engine()
-    gs.register_event({
-        'type': 'game_start',
-        'move': '',
-        'player': 'SYSTEM',
-        'fen': gs.board.fen(),
-        'value': 0.0
-    })
-    st.session_state.initialized = True
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# HEADER
-# ═══════════════════════════════════════════════════════════════════════════════
-
-st.title("🏁 CASCADE LATTICE CHESS")
-st.markdown("**Human-in-the-loop chess with cryptographic provenance via cascade-lattice**")
-
-# Top stats bar
-col1, col2, col3, col4, col5 = st.columns(5)
-with col1:
-    if gs.session.current_combo >= 3:
-        st.markdown(f"<span class='combo-display'>🔥 COMBO x{gs.session.current_combo}</span>", unsafe_allow_html=True)
-    elif gs.session.current_combo > 0:
-        st.metric("Combo", f"x{gs.session.current_combo}")
-with col2:
-    or_color = "🔴" if gs.session.override_rate > 0.5 else "🟢"
-    st.metric("Override Rate", f"{or_color} {gs.session.override_rate*100:.0f}%")
-with col3:
-    st.metric("Total Holds", gs.session.total_holds)
-with col4:
-    st.metric("Max Combo", gs.session.max_combo)
-with col5:
-    auto_label = "🟢 AUTO ON" if gs.auto_mode else "⚫ AUTO OFF"
-    if st.button(auto_label, key="auto_toggle"):
-        gs.auto_mode = not gs.auto_mode
-        st.rerun()
-
-st.divider()
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# MAIN LAYOUT
-# ═══════════════════════════════════════════════════════════════════════════════
-
-board_col, panel_col = st.columns([1, 1.5])
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# BOARD COLUMN
-# ═══════════════════════════════════════════════════════════════════════════════
-
-with board_col:
-    # Generate SVG with arrows if in drill mode
-    arrows = []
-    if gs.ui_mode == "DRILL" and gs.candidates and gs.selected_idx < len(gs.candidates):
-        selected = gs.candidates[gs.selected_idx]
-        try:
-            move = chess.Move.from_uci(selected['move'])
-            arrows.append(chess.svg.Arrow(move.from_square, move.to_square, color="#ffd700"))
-            
-            # Show predicted responses
-            temp = gs.board.copy()
-            temp.push(move)
-            for resp in list(temp.legal_moves)[:3]:
-                arrows.append(chess.svg.Arrow(resp.from_square, resp.to_square, color="#00c8ff80"))
-        except:
-            pass
-    
-    svg = chess.svg.board(gs.board, arrows=arrows, size=450)
-    st.markdown(f'<div style="display:flex;justify-content:center;">{svg}</div>', unsafe_allow_html=True)
-    
-    # Status bar under board
-    status_col1, status_col2, status_col3 = st.columns(3)
-    with status_col1:
-        if gs.hold_active:
-            hold_time = gs.get_hold_duration()
-            st.markdown(f"⏸️ **HOLD** {hold_time:.1f}s")
-        else:
-            st.markdown("● Observing")
-    with status_col2:
-        st.markdown(f"Moves: {len(gs.move_history)}")
-    with status_col3:
-        st.markdown(f"<span class='merkle-hash'>Chain: {len(gs.merkle_chain)}</span>", unsafe_allow_html=True)
-    
-    # Last evaluation
-    if gs.last_observation:
-        e = gs.last_observation.get('evaluation', [])
-        if e:
-            eval_val = e[2] - e[0]
-            color = "🟢" if eval_val > 0.1 else "🔴" if eval_val < -0.1 else "⚪"
-            st.markdown(f"**Eval:** {color} {eval_val:+.3f}")
-    
-    # New Game button
-    if st.button("🔄 NEW GAME", use_container_width=True):
-        gs.reset_game()
-        gs.causal_chain = []
-        gs.merkle_chain = []
-        gs.value_history = []
-        gs.register_event({
-            'type': 'game_start',
-            'move': '',
-            'player': 'SYSTEM',
-            'fen': gs.board.fen(),
-            'value': 0.0
-        })
-        st.rerun()
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PANEL COLUMN
-# ═══════════════════════════════════════════════════════════════════════════════
-
-with panel_col:
-    # Game over state
-    if gs.game_over:
-        st.error(f"🏁 GAME OVER: {gs.game_result}")
-        st.balloons()
-    
-    # Tab system
-    tab1, tab2, tab3, tab4 = st.tabs(["📊 WEALTH", "🔮 CASCADE", "📈 METRICS", "🔗 CHAIN"])
-    
-    # ═══════════════════════════════════════════════════════════════════════════
-    # WEALTH TAB
-    # ═══════════════════════════════════════════════════════════════════════════
-    
-    with tab1:
-        if not gs.hold_active and not gs.game_over:
-            # Trigger AI turn
-            if gs.board.turn == chess.WHITE:
-                with st.spinner("ChessBot thinking..."):
-                    ai_move, candidates, value = gs.get_ai_move()
-                    if candidates:
-                        gs.candidates = candidates
-                        gs.predictions = gs.predict_cascade(candidates)
-                        gs.hold_active = True
-                        gs.start_hold_timer()
-                        gs.current_merkle = gs._compute_merkle({'fen': gs.board.fen(), 'candidates': [c['move'] for c in candidates]})
-                        gs.selected_idx = 0
-                        gs.last_observation = {'evaluation': candidates[0].get('v_head', [0.33, 0.34, 0.33])}
-                        gs.check_anomalies({'confidence': candidates[0]['prob']})
-                        st.rerun()
-            else:
-                # Stockfish turn
-                with st.spinner("Stockfish responding..."):
-                    sf_move = gs.get_stockfish_move()
-                    gs.make_move(sf_move, "Stockfish", False)
-                    st.rerun()
-        
-        if gs.hold_active:
-            st.subheader("🎯 CASCADE HOLD // SELECT MOVE")
-            
-            hold_time = gs.get_hold_duration()
-            timer_color = "red" if hold_time > 10 else "blue"
-            st.markdown(f"⏱️ Hold time: **:{timer_color}[{hold_time:.1f}s]**")
-            
-            if gs.ui_mode == "LIST":
-                # Candidate list view
-                for i, c in enumerate(gs.candidates):
-                    pred = next((p for p in gs.predictions if p.move == c['move']), None)
-                    
-                    # Risk color
-                    if pred:
-                        if pred.risk_score < 0.3:
-                            risk_class = "risk-low"
-                            risk_label = "LOW"
-                        elif pred.risk_score < 0.6:
-                            risk_class = "risk-med"
-                            risk_label = "MED"
-                        else:
-                            risk_class = "risk-high"
-                            risk_label = "HIGH"
-                    else:
-                        risk_class = "risk-low"
-                        risk_label = "?"
-                    
-                    col_a, col_b, col_c = st.columns([3, 1, 1])
-                    with col_a:
-                        vh = c.get('v_head', [0,0,0])
-                        st.markdown(f"""
-                        **#{i+1} {c['move']}** ({c['prob']*100:.1f}%)  
-                        W:{vh[2]:.2f} D:{vh[1]:.2f} B:{vh[0]:.2f}
-                        """)
-                    with col_b:
-                        st.markdown(f"<span class='{risk_class}'>{risk_label}</span>", unsafe_allow_html=True)
-                    with col_c:
-                        if st.button("DRILL", key=f"drill_{i}"):
-                            gs.selected_idx = i
-                            gs.ui_mode = "DRILL"
-                            st.rerun()
-                    
-                    # Threats
-                    if pred and pred.tactical_threats:
-                        for threat in pred.tactical_threats[:2]:
-                            st.markdown(f"<span class='threat-badge'>⚠️ {threat}</span>", unsafe_allow_html=True)
-                    
-                    st.divider()
-            
-            elif gs.ui_mode == "DRILL":
-                # Drill view
-                if st.button("← BACK TO LIST"):
-                    gs.ui_mode = "LIST"
-                    st.rerun()
-                
-                if gs.selected_idx < len(gs.candidates):
-                    c = gs.candidates[gs.selected_idx]
-                    pred = next((p for p in gs.predictions if p.move == c['move']), None)
-                    
-                    st.subheader(f"🔍 ANALYZING: {c['move']}")
-                    
-                    # Risk badge
-                    if pred:
-                        if pred.risk_score < 0.3:
-                            st.success(f"RISK: LOW ({pred.risk_score:.2f})")
-                        elif pred.risk_score < 0.6:
-                            st.warning(f"RISK: MEDIUM ({pred.risk_score:.2f})")
-                        else:
-                            st.error(f"RISK: HIGH ({pred.risk_score:.2f})")
-                    
-                    # Provenance block
-                    st.markdown(f"""
-                    <div class='metric-card'>
-                    <strong>CRYPTOGRAPHIC CHAIN</strong><br>
-                    <span class='merkle-hash'>{gs.merkle_chain[-1] if gs.merkle_chain else 'GENESIS'} → {gs.current_merkle}</span><br>
-                    Chain: {len(gs.merkle_chain)} blocks
-                    </div>
-                    """, unsafe_allow_html=True)
-                    
-                    # Metrics grid
-                    m1, m2, m3 = st.columns(3)
-                    with m1:
-                        st.metric("Confidence", f"{c['prob']*100:.2f}%")
-                        st.progress(c['prob'])
-                    with m2:
-                        vh = c.get('v_head', [0,0,0])
-                        st.markdown("**NNUE Value Head**")
-                        st.progress(vh[2], text=f"W: {vh[2]:.3f}")
-                        st.progress(vh[1], text=f"D: {vh[1]:.3f}")
-                        st.progress(vh[0], text=f"B: {vh[0]:.3f}")
-                    with m3:
-                        if pred:
-                            st.markdown("**CASCADE PREDICTION**")
-                            mat_color = "🟢" if pred.material_delta >= 0 else "🔴"
-                            pos_color = "🟢" if pred.positional_delta >= 0 else "🔴"
-                            st.markdown(f"Material: {mat_color} {pred.material_delta:+d}")
-                            st.markdown(f"Position: {pos_color} {pred.positional_delta:+.3f}")
-                            if pred.predicted_responses:
-                                st.markdown(f"Response: `{pred.predicted_responses[0]}`")
-                    
-                    # Reasoning
-                    st.markdown("**DECISION FORMULATION**")
-                    reason_text = c.get('reason', 'No reasoning')
-                    if pred and pred.tactical_threats:
-                        reason_text += f" | THREATS: {', '.join(pred.tactical_threats)}"
-                    st.info(reason_text)
-                    
-                    # Action buttons
-                    btn1, btn2 = st.columns(2)
-                    with btn1:
-                        if st.button(f"✅ EXECUTE: {c['move']}", type="primary", use_container_width=True):
-                            was_override = gs.selected_idx != 0
-                            gs.make_move(c['move'], "ChessBot" + (" (OVERRIDE)" if was_override else ""), was_override)
-                            gs.hold_active = False
-                            gs.ui_mode = "LIST"
-                            st.rerun()
-                    with btn2:
-                        st.caption("Or select another candidate to override")
-    
-    # ═══════════════════════════════════════════════════════════════════════════
-    # CASCADE TAB
-    # ═══════════════════════════════════════════════════════════════════════════
-    
-    with tab2:
-        st.subheader("🔮 CASCADE PREDICTIONS // MINORITY REPORT")
-        
-        if not gs.predictions:
-            st.info("Waiting for HOLD point to generate predictions...")
-        else:
-            for pred in gs.predictions[:6]:
-                if pred.risk_score < 0.3:
-                    border_color = "#00ff96"
-                elif pred.risk_score < 0.6:
-                    border_color = "#ff9632"
-                else:
-                    border_color = "#ff4646"
-                
-                st.markdown(f"""
-                <div style='border-left: 3px solid {border_color}; padding: 10px; margin: 10px 0; background: #2d2d3a;'>
-                <strong>{pred.move}</strong> - Risk: {pred.risk_score:.2f}<br>
-                Chain: {' → '.join(pred.predicted_responses[:3])}<br>
-                Material: {pred.material_delta:+d} | Position: {pred.positional_delta:+.3f}<br>
-                {('⚠️ ' + ', '.join(pred.tactical_threats)) if pred.tactical_threats else ''}
-                {'🔴 INTERVENTION POINT' if pred.intervention_point else ''}
-                </div>
-                """, unsafe_allow_html=True)
-    
-    # ═══════════════════════════════════════════════════════════════════════════
-    # METRICS TAB
-    # ═══════════════════════════════════════════════════════════════════════════
-    
-    with tab3:
-        st.subheader("📈 REAL-TIME METRICS ENGINE")
-        
-        m1, m2 = st.columns(2)
-        with m1:
-            st.metric("Total Holds", gs.session.total_holds)
-            st.metric("Human Overrides", gs.session.human_overrides)
-            st.metric("AI Accepted", gs.session.ai_accepted)
-            st.metric("Override Rate", f"{gs.session.override_rate*100:.1f}%")
-        with m2:
-            st.metric("Current Combo", gs.session.current_combo)
-            st.metric("Max Combo", gs.session.max_combo)
-            st.metric("Avg Decision Time", f"{gs.session.avg_decision_time:.2f}s")
-            st.metric("Speed Bonus", f"{gs.session.speed_bonus:.2f}")
-        
-        # Value history chart
-        if gs.value_history:
-            st.markdown("**VALUE HISTORY**")
-            st.line_chart(gs.value_history)
-        
-        # Graph stats
-        stats = gs.causation_graph.get_stats()
-        st.markdown("**CAUSATION GRAPH**")
-        for k, v in stats.items():
-            st.markdown(f"- {k}: {v}")
-    
-    # ═══════════════════════════════════════════════════════════════════════════
-    # CHAIN TAB
-    # ═══════════════════════════════════════════════════════════════════════════
-    
-    with tab4:
-        st.subheader("🔗 MERKLE PROVENANCE CHAIN")
-        
-        if not gs.causal_chain:
-            st.info("Chain empty. Waiting for game events...")
-        else:
-            for node in gs.causal_chain[-12:]:
-                override_style = "border-left: 3px solid #ffa500;" if node.was_override else ""
-                val_color = "#00ff96" if node.value > 0 else "#ff4646" if node.value < 0 else "#888"
-                
-                st.markdown(f"""
-                <div style='background: #2d2d3a; padding: 10px; margin: 5px 0; {override_style}'>
-                <strong>#{node.depth}</strong> {node.move or 'START'} ({node.player})<br>
-                <span class='merkle-hash'>{node.merkle}</span>
-                <span style='color: {val_color}; float: right;'>v: {node.value:+.3f}</span>
-                </div>
-                """, unsafe_allow_html=True)
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# AUTO MODE HANDLING
-# ═══════════════════════════════════════════════════════════════════════════════
-
-if gs.auto_mode and gs.hold_active and not gs.game_over:
-    time.sleep(1.5)
-    # Auto-execute top choice
-    if gs.candidates:
-        gs.make_move(gs.candidates[0]['move'], "ChessBot", False)
-        gs.hold_active = False
-        
-        # Stockfish responds
-        if not gs.game_over and gs.board.turn == chess.BLACK:
-            sf_move = gs.get_stockfish_move()
-            gs.make_move(sf_move, "Stockfish", False)
-        
-        st.rerun()
-
-# Footer
-st.divider()
-st.markdown("""
-<div style='text-align: center; color: #666;'>
-<small>CASCADE LATTICE CHESS // Powered by <a href='https://pypi.org/project/cascade-lattice/'>cascade-lattice</a> + <a href='https://huggingface.co/Maxlegrec/ChessBot'>ChessBot</a></small>
-</div>
-""", unsafe_allow_html=True)

main.py

@@ -45,7 +45,7 @@ COLORS = {
 
 # Initialize Pygame
 pygame.init()
-pygame.display.set_caption("CASCADE LATTICE CHESS // SUPER SAIYAN MODE")
+pygame.display.set_caption("CASCADE LATTICE CHESS")
 screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
 font = pygame.font.SysFont("Consolas", 14)
 font_mono = pygame.font.SysFont("Consolas", 12)
@@ -55,7 +55,7 @@ title_font = pygame.font.SysFont("Consolas", 24, bold=True)
 header_font = pygame.font.SysFont("Consolas", 16, bold=True)
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# CASCADE LATTICE SUPER SYSTEMS
+# CASCADE LATTICE SYSTEMS
 # ═══════════════════════════════════════════════════════════════════════════════
 
 @dataclass
@@ -108,10 +108,10 @@ class SessionStats:
     avg_decision_time: float = 0.0
     decision_times: List[float] = field(default_factory=list)
 
-class CascadeSuperSystem:
+class CascadeSystem:
     """
-    The SUPER SAIYAN integration layer.
-    Connects all cascade-lattice subsystems for maximum informational wealth.
+    The main integration layer.
+    Connects all cascade-lattice subsystems for informational wealth.
     """
     def __init__(self):
         # Core cascade systems
@@ -410,8 +410,8 @@ class CascadeSuperSystem:
         return self.merkle_chain[-n:] if self.merkle_chain else []
 
 
-# Global super system instance
-super_system: Optional[CascadeSuperSystem] = None
+# Global cascade system instance
+cascade_system: Optional[CascadeSystem] = None
 
 def draw_text_wrapped(surf, text, font, color, rect, line_height=None):
     """Draw wrapped text within a rectangle"""
@@ -476,7 +476,7 @@ def draw_sparkline(surf, rect, values, color, max_val=None):
 
 class ChessGUI:
     """
-    SUPER SAIYAN GUI - Maximum Informational Wealth Display
+    Chess GUI - Informational Wealth Display
     """
     def __init__(self):
         self.board = chess.Board()
@@ -490,11 +490,11 @@ class ChessGUI:
         self.auto_mode = False
         self.game_result = None
         
-        # Super system reference
-        global super_system
-        if super_system is None:
-            super_system = CascadeSuperSystem()
-        self.super_system = super_system
+        # Cascade system reference
+        global cascade_system
+        if cascade_system is None:
+            cascade_system = CascadeSystem()
+        self.cascade_system = cascade_system
         
         # Visual state
         self.pulse_phase = 0
@@ -516,7 +516,7 @@ class ChessGUI:
     def on_hold(self, hold_point):
         self.hold_point = hold_point
         self.selected_move_idx = 0
-        self.super_system.start_hold_timer()
+        self.cascade_system.start_hold_timer()
         
         if self.auto_mode:
             self.ui_mode = "DRILL"
@@ -528,11 +528,11 @@ class ChessGUI:
         if hasattr(hold_point, 'observation'):
             obs = hold_point.observation
             candidates = obs.get('candidates', [])
-            self.super_system.predict_cascade(self.board, candidates)
+            self.cascade_system.predict_cascade(self.board, candidates)
             
             # Check for anomalies
             if candidates:
-                self.super_system.check_anomalies({
+                self.cascade_system.check_anomalies({
                     'confidence': candidates[0]['prob'],
                     'value': candidates[0].get('v_head', [0,0,0])[2] - candidates[0].get('v_head', [0,0,0])[0]
                 })
@@ -619,7 +619,7 @@ class ChessGUI:
         pygame.draw.circle(screen, (255, 255, 255), (x, y), 6, 1)
 
     def draw_panel(self):
-        """SUPER SAIYAN PANEL - Full analytical wealth display"""
+        """Main panel - Full analytical wealth display"""
         # Main panel background
         panel_rect = pygame.Rect(BOARD_SIZE, 0, PANEL_SIZE, WINDOW_HEIGHT)
         pygame.draw.rect(screen, COLORS['bg_panel'], panel_rect)
@@ -642,7 +642,7 @@ class ChessGUI:
         screen.blit(title, (BOARD_SIZE + 15, y))
         
         # Session stats bar (top right)
-        stats = self.super_system.session
+        stats = self.cascade_system.session
         stats_x = BOARD_SIZE + PANEL_SIZE - 320
         
         # Combo display with glow
@@ -776,7 +776,7 @@ class ChessGUI:
         x = content_rect.x + 10
         
         # Hold timer
-        hold_duration = self.super_system.get_hold_duration()
+        hold_duration = self.cascade_system.get_hold_duration()
         timer_color = COLORS['accent_red'] if hold_duration > 10 else COLORS['accent_cyan']
         timer_text = font.render(f"HOLD TIME: {hold_duration:.1f}s", True, timer_color)
         screen.blit(timer_text, (content_rect.right - 130, y))
@@ -788,7 +788,7 @@ class ChessGUI:
         
         obs = getattr(self.hold_point, 'observation', {})
         candidates = obs.get('candidates', [])
-        predictions = self.super_system.predictions
+        predictions = self.cascade_system.predictions
         
         # Header row
         headers = ["RK", "MOVE", "CONF", "VALUE", "RISK", "THREATS"]
@@ -869,7 +869,7 @@ class ChessGUI:
             return
             
         c = candidates[self.selected_move_idx]
-        predictions = self.super_system.predictions
+        predictions = self.cascade_system.predictions
         pred = next((p for p in predictions if p.move == c['move']), None)
         
         # Back button
@@ -909,9 +909,9 @@ class ChessGUI:
         screen.blit(chain_text, (x + 8, y + 22))
         
         # Chain integrity indicator
-        chain_ok = len(self.super_system.merkle_chain) > 0
+        chain_ok = len(self.cascade_system.merkle_chain) > 0
         integrity_color = COLORS['accent_green'] if chain_ok else COLORS['accent_red']
-        integrity_text = font_small.render(f"CHAIN: {len(self.super_system.merkle_chain)} BLOCKS", True, integrity_color)
+        integrity_text = font_small.render(f"CHAIN: {len(self.cascade_system.merkle_chain)} BLOCKS", True, integrity_color)
         screen.blit(integrity_text, (prov_rect.right - 120, y + 15))
         
         y += 60
@@ -1012,7 +1012,7 @@ class ChessGUI:
         screen.blit(header_font.render("CASCADE PREDICTIONS // MINORITY REPORT", True, COLORS['accent_purple']), (x, y))
         y += 30
         
-        predictions = self.super_system.predictions
+        predictions = self.cascade_system.predictions
         if not predictions:
             screen.blit(font.render("No predictions available. Waiting for HOLD point...", True, COLORS['text_muted']), (x, y))
             return
@@ -1070,7 +1070,7 @@ class ChessGUI:
         screen.blit(header_font.render("REAL-TIME METRICS ENGINE", True, COLORS['accent_cyan']), (x, y))
         y += 30
         
-        stats = self.super_system.session
+        stats = self.cascade_system.session
         
         # Session metrics grid
         metrics = [
@@ -1108,7 +1108,7 @@ class ChessGUI:
         y += 75
         
         # Graph stats
-        graph_stats = self.super_system.get_graph_stats()
+        graph_stats = self.cascade_system.get_graph_stats()
         screen.blit(font.render("CAUSATION GRAPH", True, COLORS['text_secondary']), (x, y))
         y += 20
         for key, val in list(graph_stats.items())[:4]:
@@ -1123,7 +1123,7 @@ class ChessGUI:
         screen.blit(header_font.render("MERKLE PROVENANCE CHAIN", True, COLORS['merkle_glow']), (x, y))
         y += 30
         
-        chain = self.super_system.causal_chain
+        chain = self.cascade_system.causal_chain
         if not chain:
             screen.blit(font.render("Chain empty. Waiting for game events...", True, COLORS['text_muted']), (x, y))
             return
@@ -1173,7 +1173,7 @@ class ChessGUI:
 
     def _draw_anomaly_alerts(self, content_rect):
         """Draw anomaly alerts at bottom of content area"""
-        anomalies = list(self.super_system.anomalies)[-3:]
+        anomalies = list(self.cascade_system.anomalies)[-3:]
         if not anomalies:
             return
         
@@ -1223,7 +1223,7 @@ class ChessGUI:
                         self.draw_board()
                         
                         # Get prediction for this move
-                        pred = next((p for p in self.super_system.predictions if p.move == selected_move_uci), None)
+                        pred = next((p for p in self.cascade_system.predictions if p.move == selected_move_uci), None)
                         
                         # ANCHOR MOVE - Gold with glow
                         self.draw_arrow(move.from_square, move.to_square, 
@@ -1306,7 +1306,7 @@ class ChessGUI:
             screen.blit(label, (x + 25, y))
             
             # Hold timer
-            hold_time = self.super_system.get_hold_duration()
+            hold_time = self.cascade_system.get_hold_duration()
             timer_text = font.render(f"{hold_time:.1f}s", True, COLORS['text_muted'])
             screen.blit(timer_text, (x + 100, y))
         else:
@@ -1314,12 +1314,12 @@ class ChessGUI:
             screen.blit(status_text, (x, y))
         
         # Move counter
-        move_count = len(self.super_system.move_history)
+        move_count = len(self.cascade_system.move_history)
         moves_text = font.render(f"Moves: {move_count}", True, COLORS['text_secondary'])
         screen.blit(moves_text, (x + 180, y))
         
         # Merkle chain length
-        chain_len = len(self.super_system.merkle_chain)
+        chain_len = len(self.cascade_system.merkle_chain)
         chain_text = font.render(f"Chain: {chain_len}", True, COLORS['merkle_glow'])
         screen.blit(chain_text, (x + 280, y))
         
@@ -1422,10 +1422,10 @@ class ChessGUI:
         selected_move = candidates[self.selected_move_idx]['move']
         ai_move = obs.get('suggested_move', candidates[0]['move'])
         was_override = selected_move != ai_move
-        decision_time = self.super_system.get_hold_duration()
+        decision_time = self.cascade_system.get_hold_duration()
         
-        # Record the decision in super system
-        self.super_system.record_decision(
+        # Record the decision in cascade system
+        self.cascade_system.record_decision(
             was_override=was_override,
             decision_time=decision_time,
             ai_move=ai_move,
@@ -1434,7 +1434,7 @@ class ChessGUI:
         )
         
         # Register event in causation graph
-        self.super_system.register_event({
+        self.cascade_system.register_event({
             'type': 'hold_resolution',
             'move': selected_move,
             'player': 'ChessBot' + (' (OVERRIDE)' if was_override else ''),
@@ -1453,7 +1453,7 @@ class ChessGUI:
 
 class ChessModelPlayer:
     """
-    SUPER SAIYAN Model Player - Full cascade integration
+    CASCADE Model Player - Full cascade integration
     """
     def __init__(self, model_name, gui=None):
         print(f"Loading chess model {model_name}...")
@@ -1469,16 +1469,16 @@ class ChessModelPlayer:
         self.hold = cascade.Hold.get()
         self.hold.timeout = 3600  # 1 hour for deep observation
         
-        # Super system reference
-        global super_system
-        if super_system is None:
-            super_system = CascadeSuperSystem()
-        self.super_system = super_system
+        # Cascade system reference
+        global cascade_system
+        if cascade_system is None:
+            cascade_system = CascadeSystem()
+        self.cascade_system = cascade_system
         
-        print(f"[SUPER SAIYAN] Cascade systems initialized")
-        print(f"[SUPER SAIYAN] CausationGraph: ACTIVE")
-        print(f"[SUPER SAIYAN] MetricsEngine: ACTIVE")
-        print(f"[SUPER SAIYAN] Tracer: ACTIVE")
+        print(f"[CASCADE] Cascade systems initialized")
+        print(f"[CASCADE] CausationGraph: ACTIVE")
+        print(f"[CASCADE] MetricsEngine: ACTIVE")
+        print(f"[CASCADE] Tracer: ACTIVE")
 
     def get_move(self, board):
         fen = board.fen()
@@ -1539,7 +1539,7 @@ class ChessModelPlayer:
                     "draw": float(pos_eval[1]),
                     "black_win": float(pos_eval[0])
                 },
-                "move_number": len(self.super_system.move_history) + 1,
+                "move_number": len(self.cascade_system.move_history) + 1,
                 "legal_move_count": len(legal_moves)
             },
             brain_id=MODEL_NAME,
@@ -1678,7 +1678,7 @@ class ChessModelPlayer:
         self.monitor.observe(obs_data)
         
         # Register in causation graph
-        self.super_system.register_event({
+        self.cascade_system.register_event({
             'type': 'move',
             'move': move.uci(),
             'player': player_name,
@@ -1691,18 +1691,18 @@ class ChessModelPlayer:
 
 def play_game():
     """
-    SUPER SAIYAN GAME LOOP
+    CASCADE GAME LOOP
     Full cascade-lattice integration with all subsystems active
     """
     print("=" * 60)
-    print("  CASCADE LATTICE CHESS // SUPER SAIYAN MODE")
+    print("  CASCADE LATTICE CHESS")
     print("=" * 60)
     print()
     print("Systems Initializing...")
     
-    # Initialize super system first
-    global super_system
-    super_system = CascadeSuperSystem()
+    # Initialize cascade system first
+    global cascade_system
+    cascade_system = CascadeSystem()
     
     gui = ChessGUI()
     chess_player = ChessModelPlayer(MODEL_NAME, gui)
@@ -1724,7 +1724,7 @@ def play_game():
             move_count = 0
             
             # Register game start event
-            super_system.register_event({
+            cascade_system.register_event({
                 'type': 'game_start',
                 'move': '',
                 'player': 'SYSTEM',
@@ -1765,7 +1765,7 @@ def play_game():
                 gui.game_result = msg
                 
                 # Register game end event
-                super_system.register_event({
+                cascade_system.register_event({
                     'type': 'game_end',
                     'move': '',
                     'player': 'SYSTEM',
@@ -1780,14 +1780,14 @@ def play_game():
                 print("=" * 60)
                 print()
                 print("Session Statistics:")
-                stats = super_system.session
+                stats = cascade_system.session
                 print(f"  Total Holds: {stats.total_holds}")
                 print(f"  Human Overrides: {stats.human_overrides}")
                 print(f"  Override Rate: {stats.override_rate*100:.1f}%")
                 print(f"  Max Combo: {stats.max_combo}")
                 print(f"  Avg Decision Time: {stats.avg_decision_time:.2f}s")
-                print(f"  Causation Chain Length: {len(super_system.causal_chain)}")
-                print(f"  Merkle Blocks: {len(super_system.merkle_chain)}")
+                print(f"  Causation Chain Length: {len(cascade_system.causal_chain)}")
+                print(f"  Merkle Blocks: {len(cascade_system.merkle_chain)}")
                 
         print("[SYSTEM] Game loop finished")
 
@@ -1810,3 +1810,4 @@ def play_game():
 
 if __name__ == "__main__":
     play_game()
+

requirements.txt

@@ -1,7 +1,4 @@
-streamlit
-chess
-torch
-transformers
-numpy
-Pillow
-cascade-lattice>=0.5.0
+streamlit>=1.28.0
+chess>=1.10.0
+numpy>=1.24.0
+Pillow>=10.0.0

src/streamlit_app.py

@@ -0,0 +1,1314 @@
+import streamlit as st
+import chess
+import chess.svg
+import chess.engine
+import os
+import random
+import time
+import math
+import hashlib
+from collections import deque
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional, Tuple
+
+# Try to import torch/transformers for model support
+try:
+    import torch
+    from transformers import AutoModel
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+# Configuration
+MODEL_NAME = "Maxlegrec/ChessBot"
+STOCKFISH_PATH = "/usr/games/stockfish"
+
+# Color Palette - Industrial Neon (for CSS)
+COLORS = {
+    'bg_dark': '#121216',
+    'bg_panel': '#19191e',
+    'bg_card': '#23232d',
+    'bg_card_hover': '#2d3241',
+    'accent_cyan': '#00c8ff',
+    'accent_green': '#00ff96',
+    'accent_gold': '#ffd700',
+    'accent_red': '#ff4646',
+    'accent_purple': '#b464ff',
+    'accent_orange': '#ff9632',
+    'text_primary': '#ffffff',
+    'text_secondary': '#b4b4b4',
+    'text_muted': '#787878',
+    'merkle_glow': '#64ffda',
+    'anomaly_pulse': '#ff3264',
+    'combo_gold': '#ffc832',
+    'prediction_blue': '#3296ff',
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# CASCADE LATTICE SYSTEMS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class CausalNode:
+    """A node in the causal chain visualization"""
+    event_id: str
+    move: str
+    player: str
+    fen: str
+    timestamp: float
+    merkle: str
+    value: float
+    was_override: bool = False
+    children: List[str] = field(default_factory=list)
+    depth: int = 0
+
+@dataclass  
+class PredictionRisk:
+    """Cascade prediction with risk assessment"""
+    move: str
+    risk_score: float
+    predicted_responses: List[str]
+    material_delta: int
+    positional_delta: float
+    tactical_threats: List[str]
+    intervention_point: bool = False
+
+@dataclass
+class AnomalyAlert:
+    """Real-time anomaly detection"""
+    timestamp: float
+    metric_name: str
+    expected_value: float
+    actual_value: float
+    deviation_sigma: float
+    severity: str
+    message: str
+
+@dataclass
+class SessionStats:
+    """Session tracking"""
+    total_holds: int = 0
+    human_overrides: int = 0
+    ai_accepted: int = 0
+    current_combo: int = 0
+    max_combo: int = 0
+    correct_predictions: int = 0
+    speed_bonus: float = 0.0
+    override_rate: float = 0.0
+    avg_decision_time: float = 0.0
+    decision_times: List[float] = field(default_factory=list)
+
+
+class CascadeSystem:
+    """
+    The main integration layer.
+    Connects all cascade-lattice subsystems for informational wealth.
+    """
+    def __init__(self):
+        self.causal_chain: List[CausalNode] = []
+        self.predictions: List[PredictionRisk] = []
+        self.anomalies: deque = deque(maxlen=50)
+        self.session = SessionStats()
+        self.move_history: List[Dict] = []
+        self.merkle_chain: List[str] = []
+        self.hold_start_time: Optional[float] = None
+        self.last_event_id: Optional[str] = None
+        self.override_patterns: Dict[str, int] = {}
+        self.human_preferences: Dict[str, float] = {}
+        
+    def register_event(self, event_data: Dict) -> str:
+        """Register an event and track causal chain."""
+        event_id = f"evt_{len(self.causal_chain)}_{int(time.time()*1000)}"
+        
+        node = CausalNode(
+            event_id=event_id,
+            move=event_data.get('move', ''),
+            player=event_data.get('player', ''),
+            fen=event_data.get('fen', ''),
+            timestamp=time.time(),
+            merkle=event_data.get('merkle', self._compute_merkle(event_data)),
+            value=event_data.get('value', 0.0),
+            was_override=event_data.get('was_override', False),
+            depth=len(self.causal_chain)
+        )
+        
+        if self.last_event_id and self.causal_chain:
+            self.causal_chain[-1].children.append(event_id)
+        
+        self.causal_chain.append(node)
+        self.merkle_chain.append(node.merkle)
+        self.last_event_id = event_id
+        
+        return event_id
+    
+    def _compute_merkle(self, data: Dict) -> str:
+        """Compute merkle hash for data"""
+        content = str(sorted(data.items())).encode()
+        return hashlib.sha256(content).hexdigest()[:16]
+    
+    def predict_cascade(self, board: chess.Board, candidate_moves: List[Dict]) -> List[PredictionRisk]:
+        """Predict consequences before they happen."""
+        predictions = []
+        
+        for candidate in candidate_moves:
+            move_uci = candidate['move']
+            try:
+                move = chess.Move.from_uci(move_uci)
+                if move not in board.legal_moves:
+                    continue
+                    
+                temp_board = board.copy()
+                material_before = self._count_material(temp_board)
+                temp_board.push(move)
+                material_after = self._count_material(temp_board)
+                material_delta = material_after - material_before
+                
+                opponent_moves = list(temp_board.legal_moves)[:5]
+                predicted_responses = [m.uci() for m in opponent_moves]
+                threats = self._detect_threats(temp_board, move)
+                risk_score = self._calculate_risk(temp_board, move, material_delta, threats, candidate['prob'])
+                is_intervention = risk_score > 0.7 or len(threats) > 2
+                
+                predictions.append(PredictionRisk(
+                    move=move_uci,
+                    risk_score=risk_score,
+                    predicted_responses=predicted_responses,
+                    material_delta=material_delta,
+                    positional_delta=candidate.get('v_head', [0,0,0])[2] - candidate.get('v_head', [0,0,0])[0],
+                    tactical_threats=threats,
+                    intervention_point=is_intervention
+                ))
+            except Exception as e:
+                pass
+                
+        self.predictions = predictions
+        return predictions
+    
+    def _count_material(self, board: chess.Board) -> int:
+        """Count material advantage for white"""
+        values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3, 
+                  chess.ROOK: 5, chess.QUEEN: 9, chess.KING: 0}
+        score = 0
+        for square in chess.SQUARES:
+            piece = board.piece_at(square)
+            if piece:
+                val = values.get(piece.piece_type, 0)
+                score += val if piece.color == chess.WHITE else -val
+        return score
+    
+    def _detect_threats(self, board: chess.Board, last_move: chess.Move) -> List[str]:
+        """Detect tactical threats in position"""
+        threats = []
+        if board.is_check():
+            threats.append("CHECK")
+        for square in chess.SQUARES:
+            piece = board.piece_at(square)
+            if piece and piece.color == board.turn:
+                attackers = board.attackers(not board.turn, square)
+                defenders = board.attackers(board.turn, square)
+                if len(attackers) > len(defenders):
+                    threats.append(f"HANGING_{chess.square_name(square).upper()}")
+        if len(threats) > 1:
+            threats.append("FORK_THREAT")
+        back_rank = 0 if board.turn == chess.WHITE else 7
+        king_sq = board.king(board.turn)
+        if king_sq and chess.square_rank(king_sq) == back_rank:
+            threats.append("BACK_RANK_WEAK")
+        return threats[:5]
+    
+    def _calculate_risk(self, board: chess.Board, move: chess.Move, 
+                        material_delta: int, threats: List[str], confidence: float) -> float:
+        """Calculate overall risk score for a move"""
+        risk = 0.0
+        if material_delta < 0:
+            risk += min(0.3, abs(material_delta) * 0.1)
+        risk += len(threats) * 0.1
+        risk += (1 - confidence) * 0.3
+        if board.is_checkmate():
+            risk = 0.0
+        elif board.is_check():
+            risk += 0.1
+        return min(1.0, max(0.0, risk))
+    
+    def check_anomalies(self, current_data: Dict) -> List[AnomalyAlert]:
+        """Check for anomalies in current decision data"""
+        new_anomalies = []
+        if 'confidence' in current_data:
+            conf = current_data['confidence']
+            if conf < 0.3:
+                alert = AnomalyAlert(
+                    timestamp=time.time(),
+                    metric_name="confidence",
+                    expected_value=0.7,
+                    actual_value=conf,
+                    deviation_sigma=2.5,
+                    severity="WARNING",
+                    message=f"Low AI confidence: {conf*100:.1f}%"
+                )
+                new_anomalies.append(alert)
+                self.anomalies.append(alert)
+        if 'value' in current_data and len(self.move_history) > 0:
+            prev_value = self.move_history[-1].get('value', 0)
+            curr_value = current_data['value']
+            delta = abs(curr_value - prev_value)
+            if delta > 0.4:
+                alert = AnomalyAlert(
+                    timestamp=time.time(),
+                    metric_name="value_swing",
+                    expected_value=prev_value,
+                    actual_value=curr_value,
+                    deviation_sigma=delta * 5,
+                    severity="CRITICAL" if delta > 0.6 else "WARNING",
+                    message=f"Value swing: {delta*100:.1f}% shift detected"
+                )
+                new_anomalies.append(alert)
+                self.anomalies.append(alert)
+        return new_anomalies
+    
+    def record_decision(self, was_override: bool, decision_time: float, 
+                        ai_move: str, final_move: str, fen: str):
+        """Record decision for session stats and pattern learning"""
+        self.session.total_holds += 1
+        self.session.decision_times.append(decision_time)
+        self.session.avg_decision_time = sum(self.session.decision_times) / len(self.session.decision_times)
+        
+        if was_override:
+            self.session.human_overrides += 1
+            self.session.current_combo = 0
+            fen_hash = hashlib.md5(fen.encode()).hexdigest()[:8]
+            self.override_patterns[fen_hash] = self.override_patterns.get(fen_hash, 0) + 1
+        else:
+            self.session.ai_accepted += 1
+            self.session.current_combo += 1
+            self.session.max_combo = max(self.session.max_combo, self.session.current_combo)
+            if decision_time < 2.0:
+                self.session.speed_bonus += 0.1
+        
+        self.session.override_rate = (
+            self.session.human_overrides / self.session.total_holds 
+            if self.session.total_holds > 0 else 0.0
+        )
+        
+        self.move_history.append({
+            'fen': fen,
+            'ai_move': ai_move,
+            'final_move': final_move,
+            'was_override': was_override,
+            'decision_time': decision_time,
+            'timestamp': time.time()
+        })
+    
+    def start_hold_timer(self):
+        self.hold_start_time = time.time()
+    
+    def get_hold_duration(self) -> float:
+        if self.hold_start_time:
+            return time.time() - self.hold_start_time
+        return 0.0
+    
+    def get_recent_merkle_chain(self, n: int = 5) -> List[str]:
+        return self.merkle_chain[-n:] if self.merkle_chain else []
+    
+    def get_graph_stats(self) -> Dict:
+        """Get causation graph statistics"""
+        return {
+            "events": len(self.causal_chain),
+            "merkle_blocks": len(self.merkle_chain),
+            "overrides": self.session.human_overrides,
+            "anomalies": len(self.anomalies)
+        }
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# CHESS MODEL PLAYER (Optional - requires torch)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class ChessModelPlayer:
+    """
+    CASCADE Model Player - Full cascade integration with neural network
+    """
+    def __init__(self, model_name: str, cascade_sys: CascadeSystem):
+        self.model = None
+        self.device = "cpu"
+        self.cascade_system = cascade_sys
+        self.model_name = model_name
+        
+        if TORCH_AVAILABLE:
+            try:
+                print(f"Loading chess model {model_name}...")
+                self.model = AutoModel.from_pretrained(model_name, trust_remote_code=True)
+                self.device = "cuda" if torch.cuda.is_available() else "cpu"
+                self.model.to(self.device)
+                self.model.eval()
+                print(f"[CASCADE] Model loaded on {self.device}")
+            except Exception as e:
+                print(f"Could not load model: {e}")
+                self.model = None
+    
+    def get_move_and_candidates(self, board: chess.Board) -> Tuple[str, List[Dict]]:
+        """Get move recommendation and candidates from model"""
+        fen = board.fen()
+        legal_moves = [m.uci() for m in board.legal_moves]
+        candidates = []
+        
+        if self.model is not None and TORCH_AVAILABLE:
+            try:
+                with torch.no_grad():
+                    pos_eval = self.model.get_position_value(fen, device=self.device)
+                    move_uci = self.model.get_move_from_fen_no_thinking(fen, T=0.1, device=self.device)
+                    
+                    if move_uci in legal_moves:
+                        candidates.append({
+                            "move": move_uci,
+                            "prob": 0.82,
+                            "v_head": pos_eval.tolist(),
+                            "reason": "Primary engine recommendation. Optimal according to policy network.",
+                            "is_primary": True
+                        })
+                        
+                        others = [m for m in legal_moves if m != move_uci]
+                        random.shuffle(others)
+                        for i, o in enumerate(others[:4]):
+                            v_noise = [v + random.uniform(-0.08, 0.08) for v in pos_eval.tolist()]
+                            prob = max(0.01, 0.15 - (i * 0.03) + random.uniform(-0.02, 0.02))
+                            candidates.append({
+                                "move": o,
+                                "prob": prob,
+                                "v_head": v_noise,
+                                "reason": self._generate_move_reason(board, o),
+                                "is_primary": False
+                            })
+                        
+                        return move_uci, candidates
+            except Exception as e:
+                print(f"Model inference error: {e}")
+        
+        # Fallback without model
+        return None, []
+    
+    def _generate_move_reason(self, board: chess.Board, move_uci: str) -> str:
+        """Generate a reason string for a move"""
+        reasons = [
+            "Develops piece activity",
+            "Controls central squares",
+            "Prepares kingside operation",
+            "Maintains pawn structure",
+            "Creates tactical threats",
+            "Improves piece coordination",
+            "Contests key diagonal",
+            "Reinforces defensive position"
+        ]
+        
+        try:
+            move = chess.Move.from_uci(move_uci)
+            piece = board.piece_at(move.from_square)
+            
+            if piece:
+                piece_name = chess.piece_name(piece.piece_type).capitalize()
+                if board.is_capture(move):
+                    return f"{piece_name} capture - material gain potential"
+                elif piece.piece_type == chess.PAWN:
+                    return "Pawn advance - space control"
+                elif piece.piece_type in [chess.KNIGHT, chess.BISHOP]:
+                    return f"{piece_name} development - piece activity"
+                elif piece.piece_type == chess.ROOK:
+                    return "Rook activation - open file control"
+                elif piece.piece_type == chess.QUEEN:
+                    return "Queen maneuver - central pressure"
+                elif piece.piece_type == chess.KING:
+                    if abs(move.from_square - move.to_square) == 2:
+                        return "Castling - king safety"
+                    return "King repositioning"
+        except:
+            pass
+        
+        return random.choice(reasons)
+    
+    def get_material_balance(self, board: chess.Board) -> int:
+        """Calculate material balance"""
+        values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3,
+                  chess.ROOK: 5, chess.QUEEN: 9}
+        balance = 0
+        for sq in chess.SQUARES:
+            piece = board.piece_at(sq)
+            if piece and piece.piece_type in values:
+                val = values[piece.piece_type]
+                balance += val if piece.color == chess.WHITE else -val
+        return balance
+    
+    def get_center_control(self, board: chess.Board) -> float:
+        """Estimate center control"""
+        center_squares = [chess.D4, chess.D5, chess.E4, chess.E5]
+        control = 0
+        for sq in center_squares:
+            white_attackers = len(board.attackers(chess.WHITE, sq))
+            black_attackers = len(board.attackers(chess.BLACK, sq))
+            control += white_attackers - black_attackers
+        return control / 4.0
+
+    def observe_action(self, board: chess.Board, move: chess.Move, player_name: str) -> Dict:
+        """Observe and log an action"""
+        fen = board.fen()
+        pos_eval = [0.33, 0.34, 0.33]
+        
+        if self.model is not None and TORCH_AVAILABLE:
+            try:
+                with torch.no_grad():
+                    pos_eval = self.model.get_position_value(fen, device=self.device).tolist()
+            except:
+                pass
+        
+        obs_data = {
+            "role": "observer",
+            "model": self.model_name,
+            "fen": fen,
+            "move": move.uci(),
+            "player": player_name,
+            "evaluation": pos_eval,
+            "value": float(pos_eval[2] - pos_eval[0])
+        }
+        
+        self.cascade_system.register_event({
+            'type': 'move',
+            'move': move.uci(),
+            'player': player_name,
+            'fen': fen,
+            'value': float(pos_eval[2] - pos_eval[0]),
+            'was_override': False
+        })
+        
+        return obs_data
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# STREAMLIT APP
+# ═══════════════════════════════════════════════════════════════════════════════
+
+st.set_page_config(
+    page_title="CASCADE LATTICE CHESS",
+    page_icon="♟️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS - Industrial Neon Theme
+st.markdown("""
+<style>
+    .stApp {
+        background-color: #121216;
+        color: #ffffff;
+    }
+    .main-header {
+        color: #00c8ff;
+        font-family: 'Consolas', monospace;
+        font-size: 2rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+        text-shadow: 0 0 10px rgba(0, 200, 255, 0.5);
+    }
+    .sub-header {
+        color: #00c8ff;
+        font-family: 'Consolas', monospace;
+        font-size: 1.2rem;
+        border-bottom: 1px solid #00c8ff;
+        padding-bottom: 0.5rem;
+        margin-bottom: 1rem;
+    }
+    .metric-card {
+        background-color: #23232d;
+        border-radius: 8px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        border: 1px solid #3a3a4a;
+    }
+    .metric-card:hover {
+        background-color: #2d3241;
+        border-color: #00c8ff;
+    }
+    .merkle-hash {
+        font-family: 'Consolas', monospace;
+        color: #64ffda;
+        font-size: 0.85rem;
+        background-color: #1a2a2a;
+        padding: 2px 6px;
+        border-radius: 3px;
+    }
+    .risk-low { color: #00ff96; font-weight: bold; }
+    .risk-med { color: #ff9632; font-weight: bold; }
+    .risk-high { color: #ff4646; font-weight: bold; }
+    .override-tag {
+        background-color: #ff9632;
+        color: black;
+        padding: 2px 8px;
+        border-radius: 4px;
+        font-size: 0.8rem;
+        font-weight: bold;
+    }
+    .combo-display {
+        color: #ffc832;
+        font-size: 1.5rem;
+        font-weight: bold;
+        text-shadow: 0 0 10px rgba(255, 200, 50, 0.7);
+    }
+    .status-halted {
+        color: #ff4646;
+        animation: pulse 1s infinite;
+    }
+    .status-auto {
+        color: #00ff96;
+    }
+    .status-observing {
+        color: #00c8ff;
+    }
+    .candidate-row {
+        background-color: #23232d;
+        border-radius: 8px;
+        padding: 0.75rem;
+        margin: 0.5rem 0;
+        border: 1px solid #3a3a4a;
+        transition: all 0.2s;
+    }
+    .candidate-row:hover {
+        background-color: #2d3241;
+        border-color: #00c8ff;
+        box-shadow: 0 0 10px rgba(0, 200, 255, 0.3);
+    }
+    .candidate-primary {
+        border-left: 3px solid #ffd700;
+    }
+    .confidence-bar {
+        background-color: #1a1a1f;
+        border-radius: 4px;
+        height: 8px;
+        overflow: hidden;
+    }
+    .confidence-fill {
+        background: linear-gradient(90deg, #00ff96, #00c8ff);
+        height: 100%;
+        border-radius: 4px;
+    }
+    .value-positive { color: #00ff96; }
+    .value-negative { color: #ff4646; }
+    .value-neutral { color: #787878; }
+    .chain-node {
+        background-color: #1e2832;
+        border-radius: 6px;
+        padding: 0.75rem;
+        margin: 0.25rem 0;
+        border-left: 3px solid #64ffda;
+        font-family: 'Consolas', monospace;
+    }
+    .chain-node-override {
+        border-left-color: #ff9632;
+    }
+    .anomaly-alert {
+        background-color: #321818;
+        border: 1px solid #ff4646;
+        border-radius: 6px;
+        padding: 0.5rem;
+        margin: 0.25rem 0;
+    }
+    .anomaly-warning {
+        border-color: #ff9632;
+        background-color: #322818;
+    }
+    .prediction-card {
+        background-color: #23232d;
+        border-radius: 8px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        border: 2px solid #3a3a4a;
+    }
+    .prediction-card-low { border-color: #00ff96; }
+    .prediction-card-med { border-color: #ff9632; }
+    .prediction-card-high { border-color: #ff4646; }
+    .intervention-marker {
+        background-color: #ff4646;
+        color: white;
+        border-radius: 50%;
+        width: 24px;
+        height: 24px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        font-weight: bold;
+    }
+    .sparkline-container {
+        background-color: #1a1a1f;
+        border-radius: 4px;
+        padding: 4px;
+        height: 40px;
+    }
+    @keyframes pulse {
+        0%, 100% { opacity: 1; }
+        50% { opacity: 0.5; }
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 8px;
+        background-color: #19191e;
+        padding: 4px;
+        border-radius: 8px;
+    }
+    .stTabs [data-baseweb="tab"] {
+        background-color: #23232d;
+        border-radius: 6px;
+        color: #b4b4b4;
+        font-family: 'Consolas', monospace;
+    }
+    .stTabs [aria-selected="true"] {
+        background-color: #00c8ff;
+        color: #000000;
+    }
+    .stButton>button {
+        background-color: #00966e;
+        color: white;
+        border: none;
+        font-family: 'Consolas', monospace;
+    }
+    .stButton>button:hover {
+        background-color: #00b482;
+        border: none;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def init_session_state():
+    """Initialize session state variables"""
+    if 'board' not in st.session_state:
+        st.session_state.board = chess.Board()
+    if 'cascade_system' not in st.session_state:
+        st.session_state.cascade_system = CascadeSystem()
+    if 'model_player' not in st.session_state:
+        st.session_state.model_player = None
+    if 'move_history' not in st.session_state:
+        st.session_state.move_history = []
+    if 'game_over' not in st.session_state:
+        st.session_state.game_over = False
+    if 'current_candidates' not in st.session_state:
+        st.session_state.current_candidates = []
+    if 'awaiting_decision' not in st.session_state:
+        st.session_state.awaiting_decision = False
+    if 'auto_mode' not in st.session_state:
+        st.session_state.auto_mode = False
+    if 'stockfish_engine' not in st.session_state:
+        st.session_state.stockfish_engine = None
+    if 'ai_suggested_move' not in st.session_state:
+        st.session_state.ai_suggested_move = None
+    if 'last_evaluation' not in st.session_state:
+        st.session_state.last_evaluation = [0.33, 0.34, 0.33]
+    if 'value_history' not in st.session_state:
+        st.session_state.value_history = []
+    if 'confidence_history' not in st.session_state:
+        st.session_state.confidence_history = []
+    if 'selected_move_idx' not in st.session_state:
+        st.session_state.selected_move_idx = 0
+    if 'ui_mode' not in st.session_state:
+        st.session_state.ui_mode = "LIST"  # "LIST" or "DRILL"
+    if 'last_observation' not in st.session_state:
+        st.session_state.last_observation = {}
+    if 'game_started' not in st.session_state:
+        st.session_state.game_started = False
+
+
+def get_stockfish_engine():
+    """Get or create Stockfish engine"""
+    if st.session_state.stockfish_engine is None:
+        try:
+            st.session_state.stockfish_engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
+        except Exception as e:
+            st.error(f"Could not load Stockfish: {e}")
+            return None
+    return st.session_state.stockfish_engine
+
+
+def generate_candidates(board: chess.Board) -> List[Dict]:
+    """Generate candidate moves with probabilities and reasoning"""
+    legal_moves = list(board.legal_moves)
+    if not legal_moves:
+        return []
+    
+    candidates = []
+    engine = get_stockfish_engine()
+    
+    if engine:
+        try:
+            result = engine.analyse(board, chess.engine.Limit(time=0.1), multipv=min(5, len(legal_moves)))
+            for i, info in enumerate(result if isinstance(result, list) else [result]):
+                pv = info.get('pv', [])
+                if pv:
+                    move = pv[0]
+                    score = info.get('score', None)
+                    
+                    if score:
+                        cp = score.relative.score(mate_score=10000) if score.relative else 0
+                        cp = cp / 100.0
+                        win_prob = 1 / (1 + 10 ** (-cp / 4))
+                        draw_prob = 0.2
+                        loss_prob = max(0, 1 - win_prob - draw_prob)
+                        v_head = [loss_prob, draw_prob, win_prob]
+                    else:
+                        v_head = [0.33, 0.34, 0.33]
+                    
+                    prob = max(0.05, 0.82 - i * 0.15)
+                    candidates.append({
+                        'move': move.uci(),
+                        'prob': prob,
+                        'v_head': v_head,
+                        'reason': generate_move_reason(board, move.uci()),
+                        'is_primary': i == 0,
+                        'depth': info.get('depth', 0)
+                    })
+        except Exception as e:
+            pass
+    
+    # Fallback without engine
+    if not candidates:
+        random.shuffle(legal_moves)
+        for i, move in enumerate(legal_moves[:5]):
+            candidates.append({
+                'move': move.uci(),
+                'prob': max(0.05, 0.7 - i * 0.12),
+                'v_head': [0.33, 0.34, 0.33],
+                'reason': generate_move_reason(board, move.uci()),
+                'is_primary': i == 0,
+                'depth': 0
+            })
+    
+    return candidates
+
+
+def generate_move_reason(board: chess.Board, move_uci: str) -> str:
+    """Generate a reason string for a move"""
+    reasons = [
+        "Develops piece activity",
+        "Controls central squares",
+        "Prepares kingside operation",
+        "Maintains pawn structure",
+        "Creates tactical threats",
+        "Improves piece coordination",
+        "Contests key diagonal",
+        "Reinforces defensive position"
+    ]
+    
+    try:
+        move = chess.Move.from_uci(move_uci)
+        piece = board.piece_at(move.from_square)
+        
+        if piece:
+            piece_name = chess.piece_name(piece.piece_type).capitalize()
+            if board.is_capture(move):
+                return f"{piece_name} capture - material gain potential"
+            elif piece.piece_type == chess.PAWN:
+                return "Pawn advance - space control"
+            elif piece.piece_type in [chess.KNIGHT, chess.BISHOP]:
+                return f"{piece_name} development - piece activity"
+            elif piece.piece_type == chess.ROOK:
+                return "Rook activation - open file control"
+            elif piece.piece_type == chess.QUEEN:
+                return "Queen maneuver - central pressure"
+            elif piece.piece_type == chess.KING:
+                if abs(move.from_square - move.to_square) == 2:
+                    return "Castling - king safety"
+                return "King repositioning"
+    except:
+        pass
+    
+    return random.choice(reasons)
+
+
+def render_board(board: chess.Board, selected_move: str = None, show_threats: List[str] = None) -> str:
+    """Render chess board as SVG with optional highlights"""
+    lastmove = None
+    if st.session_state.move_history:
+        try:
+            lastmove = chess.Move.from_uci(st.session_state.move_history[-1]['move'])
+        except:
+            pass
+    
+    arrows = []
+    if selected_move:
+        try:
+            move = chess.Move.from_uci(selected_move)
+            arrows = [chess.svg.Arrow(move.from_square, move.to_square, color="#ffd700")]
+        except:
+            pass
+    
+    # Add threat indicators
+    check_squares = []
+    if show_threats:
+        for threat in show_threats:
+            if "HANGING_" in threat:
+                sq_name = threat.replace("HANGING_", "").lower()
+                try:
+                    sq = chess.parse_square(sq_name)
+                    check_squares.append(sq)
+                except:
+                    pass
+    
+    svg = chess.svg.board(
+        board,
+        size=400,
+        lastmove=lastmove,
+        arrows=arrows,
+        colors={
+            'square light': '#ebecd0',
+            'square dark': '#779556',
+        }
+    )
+    return svg
+
+
+def make_move(move_uci: str, player: str, was_override: bool = False):
+    """Execute a move on the board"""
+    board = st.session_state.board
+    cascade_sys = st.session_state.cascade_system
+    
+    try:
+        move = chess.Move.from_uci(move_uci)
+        if move in board.legal_moves:
+            board.push(move)
+            
+            # Register in cascade system
+            cascade_sys.register_event({
+                'type': 'move',
+                'move': move_uci,
+                'player': player,
+                'fen': board.fen(),
+                'value': st.session_state.last_evaluation[2] - st.session_state.last_evaluation[0],
+                'was_override': was_override
+            })
+            
+            st.session_state.move_history.append({
+                'move': move_uci,
+                'player': player,
+                'was_override': was_override,
+                'fen': board.fen()
+            })
+            
+            # Check game over
+            if board.is_game_over():
+                st.session_state.game_over = True
+            
+            return True
+    except Exception as e:
+        st.error(f"Invalid move: {e}")
+    return False
+
+
+def play_stockfish_move():
+    """Have Stockfish play a move for Black"""
+    engine = get_stockfish_engine()
+    if engine and not st.session_state.board.is_game_over():
+        try:
+            result = engine.play(st.session_state.board, chess.engine.Limit(time=0.5))
+            if result.move:
+                make_move(result.move.uci(), "Stockfish")
+        except Exception as e:
+            st.error(f"Stockfish error: {e}")
+
+
+def main():
+    init_session_state()
+    
+    # Header with session stats
+    col_title, col_stats = st.columns([2, 1])
+    with col_title:
+        st.markdown('<div class="main-header">CASCADE LATTICE CHESS</div>', unsafe_allow_html=True)
+    with col_stats:
+        stats = st.session_state.cascade_system.session
+        if stats.current_combo >= 3:
+            st.markdown(f'<div class="combo-display">🔥 COMBO x{stats.current_combo}</div>', unsafe_allow_html=True)
+        
+        override_color = "red" if stats.override_rate > 0.5 else "green"
+        st.markdown(f"OR: <span style='color:{override_color}'>{stats.override_rate*100:.0f}%</span> | HOLDS: {stats.total_holds}", unsafe_allow_html=True)
+    
+    # Layout
+    col_board, col_panel = st.columns([1, 1.3])
+    
+    board = st.session_state.board
+    cascade_sys = st.session_state.cascade_system
+    
+    with col_board:
+        # Status bar
+        if st.session_state.current_candidates and board.turn == chess.WHITE:
+            hold_duration = cascade_sys.get_hold_duration()
+            status_class = "status-halted" if not st.session_state.auto_mode else "status-auto"
+            status_text = "⏸ HALTED" if not st.session_state.auto_mode else "▶ AUTO"
+            st.markdown(f'<span class="{status_class}">{status_text}</span> | Hold: {hold_duration:.1f}s', unsafe_allow_html=True)
+        else:
+            st.markdown('<span class="status-observing">● OBSERVING</span>', unsafe_allow_html=True)
+        
+        # Render board with current selection
+        selected = None
+        threats = []
+        if st.session_state.current_candidates:
+            idx = st.session_state.selected_move_idx
+            if idx < len(st.session_state.current_candidates):
+                selected = st.session_state.current_candidates[idx]['move']
+                pred = next((p for p in cascade_sys.predictions if p.move == selected), None)
+                if pred:
+                    threats = pred.tactical_threats
+        
+        svg = render_board(board, selected, threats)
+        st.markdown(f'<div style="display:flex;justify-content:center;">{svg}</div>', unsafe_allow_html=True)
+        
+        # Board status bar
+        st.markdown("---")
+        status_cols = st.columns(4)
+        with status_cols[0]:
+            move_count = len(st.session_state.move_history)
+            st.caption(f"Moves: {move_count}")
+        with status_cols[1]:
+            chain_len = len(cascade_sys.merkle_chain)
+            st.markdown(f'<span class="merkle-hash">Chain: {chain_len}</span>', unsafe_allow_html=True)
+        with status_cols[2]:
+            if st.session_state.last_evaluation:
+                e = st.session_state.last_evaluation
+                eval_val = e[2] - e[0]
+                eval_class = "value-positive" if eval_val > 0.1 else "value-negative" if eval_val < -0.1 else "value-neutral"
+                st.markdown(f'<span class="{eval_class}">Eval: {eval_val:+.3f}</span>', unsafe_allow_html=True)
+        with status_cols[3]:
+            turn_text = "⚪ White" if board.turn == chess.WHITE else "⚫ Black"
+            st.caption(turn_text)
+        
+        # Game status
+        if st.session_state.game_over:
+            result = board.result()
+            if result == "1-0":
+                st.success("⚪ WHITE WINS (ChessBot)")
+            elif result == "0-1":
+                st.error("⚫ BLACK WINS (Stockfish)")
+            else:
+                st.info(f"DRAW: {result}")
+            
+            # End game stats
+            st.markdown("### 📊 Session Statistics")
+            st.markdown(f"""
+            - **Total Holds:** {stats.total_holds}
+            - **Human Overrides:** {stats.human_overrides}
+            - **Override Rate:** {stats.override_rate*100:.1f}%
+            - **Max Combo:** {stats.max_combo}
+            - **Avg Decision Time:** {stats.avg_decision_time:.2f}s
+            - **Causation Chain:** {len(cascade_sys.causal_chain)} events
+            - **Merkle Blocks:** {len(cascade_sys.merkle_chain)}
+            """)
+            
+            if st.button("🔄 New Game", use_container_width=True):
+                st.session_state.board = chess.Board()
+                st.session_state.move_history = []
+                st.session_state.game_over = False
+                st.session_state.current_candidates = []
+                st.session_state.cascade_system = CascadeSystem()
+                st.session_state.value_history = []
+                st.session_state.selected_move_idx = 0
+                st.session_state.last_evaluation = [0.33, 0.34, 0.33]
+                st.rerun()
+        
+        # Controls
+        st.markdown("---")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.session_state.auto_mode = st.toggle("⚡ Auto Mode", st.session_state.auto_mode)
+        with col2:
+            if st.button("🔄 Reset Game", use_container_width=True):
+                st.session_state.board = chess.Board()
+                st.session_state.move_history = []
+                st.session_state.game_over = False
+                st.session_state.current_candidates = []
+                st.session_state.cascade_system = CascadeSystem()
+                st.session_state.value_history = []
+                st.session_state.selected_move_idx = 0
+                st.session_state.last_evaluation = [0.33, 0.34, 0.33]
+                st.rerun()
+    
+    with col_panel:
+        # Tabs
+        tab_wealth, tab_cascade, tab_metrics, tab_chain = st.tabs(["WEALTH", "CASCADE", "METRICS", "CHAIN"])
+        
+        with tab_wealth:
+            # Last observation info
+            if st.session_state.last_observation:
+                obs = st.session_state.last_observation
+                e = obs.get('evaluation', st.session_state.last_evaluation)
+                if e:
+                    st.markdown(f"**NNUE:** W:{e[2]:.3f} D:{e[1]:.3f} B:{e[0]:.3f}")
+                    # Track value history
+                    val = e[2] - e[0]
+                    st.session_state.value_history.append(val)
+                    if len(st.session_state.value_history) > 100:
+                        st.session_state.value_history.pop(0)
+                
+                last_move = obs.get('move', 'N/A')
+                last_player = obs.get('player', '?')
+                st.caption(f"Last: {last_move} ({last_player})")
+            
+            if not st.session_state.game_over:
+                # White's turn - generate candidates
+                if board.turn == chess.WHITE:
+                    if not st.session_state.current_candidates:
+                        st.session_state.current_candidates = generate_candidates(board)
+                        cascade_sys.predict_cascade(board, st.session_state.current_candidates)
+                        cascade_sys.start_hold_timer()
+                    
+                    candidates = st.session_state.current_candidates
+                    predictions = cascade_sys.predictions
+                    
+                    # Hold timer display
+                    hold_duration = cascade_sys.get_hold_duration()
+                    timer_color = "red" if hold_duration > 10 else "#00c8ff"
+                    st.markdown(f'<div class="sub-header">CASCADE HOLD // SELECT MOVE <span style="color:{timer_color};float:right;">⏱ {hold_duration:.1f}s</span></div>', unsafe_allow_html=True)
+                    
+                    # Candidate table header
+                    header_cols = st.columns([1, 2, 2, 3, 2, 3])
+                    header_cols[0].markdown("**RK**")
+                    header_cols[1].markdown("**MOVE**")
+                    header_cols[2].markdown("**CONF**")
+                    header_cols[3].markdown("**VALUE HEAD**")
+                    header_cols[4].markdown("**RISK**")
+                    header_cols[5].markdown("**THREATS**")
+                    
+                    for i, c in enumerate(candidates):
+                        pred = next((p for p in predictions if p.move == c['move']), None)
+                        risk_class = "risk-low" if not pred or pred.risk_score < 0.3 else "risk-med" if pred.risk_score < 0.6 else "risk-high"
+                        primary_class = "candidate-primary" if c.get('is_primary') else ""
+                        
+                        st.markdown(f'<div class="candidate-row {primary_class}">', unsafe_allow_html=True)
+                        cols = st.columns([1, 2, 2, 3, 2, 3])
+                        
+                        with cols[0]:
+                            st.markdown(f"**#{i+1}**")
+                        with cols[1]:
+                            st.markdown(f"**{c['move']}**")
+                        with cols[2]:
+                            st.progress(c['prob'], text=f"{c['prob']*100:.1f}%")
+                        with cols[3]:
+                            vh = c['v_head']
+                            st.markdown(f"<small>W:{vh[2]:.2f} D:{vh[1]:.2f} B:{vh[0]:.2f}</small>", unsafe_allow_html=True)
+                        with cols[4]:
+                            if pred:
+                                st.markdown(f'<span class="{risk_class}">{pred.risk_score:.2f}</span>', unsafe_allow_html=True)
+                        with cols[5]:
+                            if pred and pred.tactical_threats:
+                                threat_str = ", ".join(pred.tactical_threats[:2])
+                                st.markdown(f"<small>⚠️ {threat_str[:25]}</small>", unsafe_allow_html=True)
+                        
+                        # Reason text
+                        st.caption(c.get('reason', ''))
+                        
+                        if st.button(f"⚡ Execute {c['move']}", key=f"move_{i}", use_container_width=True):
+                            ai_move = candidates[0]['move'] if candidates else c['move']
+                            was_override = c['move'] != ai_move
+                            
+                            # Update last evaluation
+                            st.session_state.last_evaluation = c['v_head']
+                            
+                            cascade_sys.record_decision(
+                                was_override=was_override,
+                                decision_time=cascade_sys.get_hold_duration(),
+                                ai_move=ai_move,
+                                final_move=c['move'],
+                                fen=board.fen()
+                            )
+                            
+                            st.session_state.last_observation = {
+                                'move': c['move'],
+                                'player': 'ChessBot' + (' (OVERRIDE)' if was_override else ''),
+                                'evaluation': c['v_head'],
+                                'fen': board.fen()
+                            }
+                            
+                            make_move(c['move'], "ChessBot" + (" (OVERRIDE)" if was_override else ""), was_override)
+                            st.session_state.current_candidates = []
+                            st.session_state.selected_move_idx = 0
+                            
+                            # Stockfish responds
+                            if not st.session_state.board.is_game_over():
+                                play_stockfish_move()
+                            
+                            st.rerun()
+                        
+                        st.markdown('</div>', unsafe_allow_html=True)
+                        st.markdown("---")
+                    
+                    # Anomaly alerts
+                    anomalies = list(cascade_sys.anomalies)[-3:]
+                    if anomalies:
+                        st.markdown("### ⚠️ Anomaly Alerts")
+                        for alert in anomalies:
+                            alert_class = "anomaly-alert" if alert.severity == "CRITICAL" else "anomaly-warning"
+                            st.markdown(f'<div class="{alert_class}">[{alert.severity}] {alert.message}</div>', unsafe_allow_html=True)
+                    
+                    # Auto mode
+                    if st.session_state.auto_mode and candidates:
+                        time.sleep(0.5)
+                        ai_move = candidates[0]['move']
+                        st.session_state.last_evaluation = candidates[0]['v_head']
+                        cascade_sys.record_decision(
+                            was_override=False,
+                            decision_time=cascade_sys.get_hold_duration(),
+                            ai_move=ai_move,
+                            final_move=ai_move,
+                            fen=board.fen()
+                        )
+                        st.session_state.last_observation = {
+                            'move': ai_move,
+                            'player': 'ChessBot',
+                            'evaluation': candidates[0]['v_head'],
+                            'fen': board.fen()
+                        }
+                        make_move(ai_move, "ChessBot")
+                        st.session_state.current_candidates = []
+                        st.session_state.selected_move_idx = 0
+                        if not st.session_state.board.is_game_over():
+                            play_stockfish_move()
+                        st.rerun()
+                else:
+                    st.info("⏳ Waiting for Stockfish...")
+                    play_stockfish_move()
+                    st.rerun()
+        
+        with tab_cascade:
+            st.markdown('<div class="sub-header">CASCADE PREDICTIONS // MINORITY REPORT</div>', unsafe_allow_html=True)
+            predictions = cascade_sys.predictions
+            if predictions:
+                for pred in predictions:
+                    risk_class = "prediction-card-low" if pred.risk_score < 0.3 else "prediction-card-med" if pred.risk_score < 0.6 else "prediction-card-high"
+                    intervention_marker = '<span class="intervention-marker">!</span>' if pred.intervention_point else ''
+                    
+                    st.markdown(f'<div class="prediction-card {risk_class}">', unsafe_allow_html=True)
+                    
+                    col1, col2 = st.columns([3, 1])
+                    with col1:
+                        st.markdown(f"**{pred.move}** {intervention_marker}", unsafe_allow_html=True)
+                        st.progress(pred.risk_score, text=f"Risk: {pred.risk_score:.2f}")
+                    with col2:
+                        mat_color = "value-positive" if pred.material_delta >= 0 else "value-negative"
+                        pos_color = "value-positive" if pred.positional_delta >= 0 else "value-negative"
+                        st.markdown(f'<span class="{mat_color}">Mat: {pred.material_delta:+d}</span>', unsafe_allow_html=True)
+                        st.markdown(f'<span class="{pos_color}">Pos: {pred.positional_delta:+.3f}</span>', unsafe_allow_html=True)
+                    
+                    # Predicted response chain
+                    if pred.predicted_responses:
+                        chain_str = " → ".join(pred.predicted_responses[:3])
+                        st.markdown(f"**Chain:** {chain_str}")
+                    
+                    # Threats
+                    if pred.tactical_threats:
+                        threat_text = ", ".join(pred.tactical_threats[:4])
+                        st.warning(f"⚠️ {threat_text}")
+                    
+                    if pred.intervention_point:
+                        st.error("🚨 INTERVENTION POINT - High risk detected")
+                    
+                    st.markdown('</div>', unsafe_allow_html=True)
+            else:
+                st.caption("No predictions available. Waiting for HOLD point...")
+        
+        with tab_metrics:
+            st.markdown('<div class="sub-header">REAL-TIME METRICS ENGINE</div>', unsafe_allow_html=True)
+            stats = cascade_sys.session
+            
+            # Session metrics grid
+            m1, m2, m3, m4 = st.columns(4)
+            m1.metric("Total Holds", stats.total_holds)
+            m2.metric("Human Overrides", stats.human_overrides, 
+                      delta=f"{stats.human_overrides}" if stats.human_overrides > 0 else None,
+                      delta_color="inverse")
+            m3.metric("AI Accepted", stats.ai_accepted,
+                      delta=f"{stats.ai_accepted}" if stats.ai_accepted > 0 else None)
+            override_delta = "High" if stats.override_rate > 0.5 else None
+            m4.metric("Override Rate", f"{stats.override_rate*100:.1f}%", delta=override_delta, delta_color="inverse")
+            
+            m5, m6, m7, m8 = st.columns(4)
+            combo_delta = f"+{stats.current_combo}" if stats.current_combo >= 3 else None
+            m5.metric("Current Combo", stats.current_combo, delta=combo_delta)
+            m6.metric("Max Combo", stats.max_combo)
+            m7.metric("Avg Decision", f"{stats.avg_decision_time:.2f}s")
+            m8.metric("Speed Bonus", f"{stats.speed_bonus:.2f}")
+            
+            st.markdown("---")
+            
+            # Value history chart
+            st.markdown("**VALUE HISTORY**")
+            if st.session_state.value_history:
+                import json
+                # Simple sparkline using markdown
+                values = st.session_state.value_history[-50:]
+                st.line_chart(values, height=100)
+            else:
+                st.caption("No value history yet.")
+            
+            st.markdown("---")
+            
+            # Graph stats
+            st.markdown("**CAUSATION GRAPH**")
+            graph_stats = cascade_sys.get_graph_stats()
+            for key, val in graph_stats.items():
+                st.markdown(f"- {key}: **{val}**")
+        
+        with tab_chain:
+            st.markdown('<div class="sub-header">MERKLE PROVENANCE CHAIN</div>', unsafe_allow_html=True)
+            chain = cascade_sys.causal_chain[-12:]
+            
+            if chain:
+                for i, node in enumerate(reversed(chain)):
+                    override_tag = '<span class="override-tag">OVERRIDE</span>' if node.was_override else ''
+                    val_color = "value-positive" if node.value > 0 else "value-negative" if node.value < 0 else "value-neutral"
+                    node_class = "chain-node-override" if node.was_override else ""
+                    
+                    st.markdown(f"""
+                    <div class="chain-node {node_class}">
+                        <strong>#{node.depth}</strong> &nbsp;
+                        <span style="font-size:1.1em;">{node.move or 'START'}</span> &nbsp;
+                        <span style="color:#888;">({node.player})</span> {override_tag}<br>
+                        <span class="merkle-hash">{node.merkle}</span><br>
+                        <span class="{val_color}">Value: {node.value:+.3f}</span>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    # Chain link arrow (except last)
+                    if i < len(chain) - 1:
+                        st.markdown('<div style="text-align:center;color:#64ffda;">↓</div>', unsafe_allow_html=True)
+            else:
+                st.caption("Chain empty. Waiting for game events...")
+    
+    # Sidebar
+    with st.sidebar:
+        st.markdown("## ⚙️ CASCADE LATTICE")
+        st.markdown(f"**Model:** `{MODEL_NAME}`")
+        st.markdown(f"**Engine:** Stockfish")
+        st.markdown(f"**Torch:** {'✅ Available' if TORCH_AVAILABLE else '❌ Not loaded'}")
+        
+        st.markdown("---")
+        
+        st.markdown("### 🎮 Controls")
+        st.markdown("""
+        - **Select** a candidate move to execute
+        - **Auto Mode** for automated play  
+        - **CASCADE** tab for predictions
+        - **METRICS** tab for session stats
+        - **CHAIN** tab for Merkle provenance
+        """)
+        
+        st.markdown("---")
+        
+        st.markdown("### 📊 Quick Stats")
+        st.markdown(f"**Moves:** {len(st.session_state.move_history)}")
+        st.markdown(f"**Chain:** {len(cascade_sys.merkle_chain)} blocks")
+        st.markdown(f"**Events:** {len(cascade_sys.causal_chain)}")
+        
+        if cascade_sys.session.current_combo >= 3:
+            st.markdown(f"🔥 **Combo:** x{cascade_sys.session.current_combo}")
+        
+        st.markdown("---")
+        
+        # Recent merkle hashes
+        st.markdown("### 🔗 Recent Merkle")
+        recent = cascade_sys.get_recent_merkle_chain(3)
+        for m in recent:
+            st.markdown(f'<span class="merkle-hash">{m}</span>', unsafe_allow_html=True)
+
+
+if __name__ == "__main__":
+    main()