Correccion de bugs del pipeline de IA, incorporo openrouter con deepseek para fallback, rate limit de login diferenciado entre prod y dev, cambios varios en UI

.claude/memory/feedback_no_chrome_devtools.md

@@ -0,0 +1,11 @@
+---
+name: No usar Chrome DevTools para verificar UI
+description: El usuario prefiere verificar los cambios de UI él mismo, sin que Claude use Chrome DevTools
+type: feedback
+---
+
+No usar Chrome DevTools MCP para tomar screenshots o interactuar con el navegador después de hacer cambios de UI. El usuario prefiere revisar los cambios visualmente por su cuenta.
+
+**Why:** El usuario lo indicó explícitamente cuando se usaban las herramientas de Chrome para verificar cambios CSS/JS.
+
+**How to apply:** Después de hacer cambios de CSS o JS en la UI, describir los cambios realizados y dejar que el usuario los verifique en el navegador.

CLAUDE.md

@@ -0,0 +1,133 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+**PolySignal** — a real-time prediction market intelligence dashboard. It fetches market data from Polymarket, enriches it with financial news via Finnhub, runs AI sentiment analysis (ModernFinBERT + Qwen3-8B), and displays signals on an interactive world map. No real trading — pure analysis and virtual simulation. Built for CIFO Barcelona La Violeta Hackathon (May 2026). UI and docs are in **Spanish**, base currency is **Euro (€)**.
+
+## Common Commands
+
+```bash
+# Development (backend + frontend simultaneously)
+npm run dev:all
+
+# Backend only (with --watch)
+npm run dev
+
+# Frontend only (Vite @ :5173)
+npm run dev:frontend
+
+# Production build (frontend)
+npm run build:frontend
+
+# Database
+npm run db:migrate    # Apply Prisma migrations
+npm run db:generate   # Regenerate Prisma client
+npm run db:studio     # Open Prisma Studio GUI
+
+# Docker
+docker-compose up --build   # Full stack on port 7860
+```
+
+Node.js **≥24.0.0** is required (enforced in package.json engines).
+
+First-time setup:
+```bash
+npm install
+cp .env.example .env   # then fill in API keys
+npm run db:migrate && npm run db:generate
+```
+
+## Architecture
+
+Monorepo with two workspaces: `backend/` (Express 5 + Socket.io) and `frontend/` (Vanilla JS + Vite).
+
+### Backend (`backend/src/`)
+
+Follows a strict **Controller → Service → Repository → Client** layered pattern. Each domain lives in its own directory:
+
+| Directory | Responsibility |
+|-----------|---------------|
+| `markets/` | Polymarket Gamma API client + sync job |
+| `signals/` | AI pipeline (aiPipeline.js) + signals service |
+| `finnhub/` | Finnhub news client + service |
+| `positions/` | Virtual position simulator + Kelly Criterion sizing |
+| `watchlist/` | User-saved markets |
+| `alerts/` | Telegram Bot notification delivery |
+| `auth/` | JWT + bcryptjs login |
+| `socket/` | Socket.io broadcaster |
+| `middlewares/` | Auth, validation, error handling, rate limiting |
+| `utils/` | Pino logger, HTTP client, Prisma singleton |
+
+Entry points: `src/index.js` (HTTP server + Socket.io setup) → `src/app.js` (Express middleware + route mounting) → `src/scheduler.js` (cron jobs).
+
+Environment/config validated at startup via **Zod** in `src/config.js` — the app crashes fast if required env vars are missing.
+
+### Scheduler Jobs
+
+| Job | Frequency | What it does |
+|-----|-----------|-------------|
+| `syncMarkets` | 30s | Fetches top 100 active Polymarket markets, broadcasts price changes via Socket.io |
+| `generateSignals` | 5m | Runs full AI pipeline on top 20 active markets |
+| `updatePositionsPnL` | 30s | Recalculates P&L for open virtual positions |
+| `processAlerts` | 1m | Checks watchlist thresholds, fires Telegram alerts |
+
+### AI Signal Pipeline (`signals/aiPipeline.js`)
+
+Three-phase flow with automatic fallbacks:
+
+1. **News filtering** — Finnhub headlines → ModernFinBERT (HF Space) → keep only scores ≥ 0.65, drop neutral
+2. **Signal generation** — market data + filtered news → Qwen3-8B (HF Space) → `{ signal, confidence, summary, keyRisk }`
+3. **Fallback chain**: HF Space → HF direct inference API → OpenRouter (deepseek-chat) → rule-based (price-trend logic)
+
+### Frontend (`frontend/src/`)
+
+Single-page app with no framework. Key modules:
+
+| File | Role |
+|------|------|
+| `app.js` | SPA routing, DOM rendering, Socket.io listeners |
+| `api.js` | REST client wrapper with JWT token management |
+| `map.js` | Leaflet world map (bubble size = volume, color = signal) |
+| `charts.js` | Chart.js sparklines + 7-day price history |
+| `simulator.js` | Virtual buy/sell logic |
+| `filters.js` | Market filtering by category, country, continent, trend |
+
+Vite proxies `/api` and `/socket.io` to backend (`localhost:7860`) during development.
+
+### Database (SQLite via Prisma)
+
+Schema at `backend/prisma/schema.prisma`. Key models:
+- `Market` — Polymarket data (prices, volume, category, country code)
+- `AISignal` — sentiment signals with confidence and risk summary
+- `Position` — virtual trades with entry/exit prices and P&L
+- `Watchlist` / `Alert` — user market tracking and Telegram history
+- `User` — auth + optional Telegram chat ID
+
+### Real-time Communication
+
+REST API at `/api/v1/*` + WebSocket events via Socket.io:
+- `market_update` — price/volume changes
+- `ai_signal` — new sentiment signals
+- `price_alert` — watchlist threshold triggers
+
+## Deployment Target
+
+The app is designed to run on **HuggingFace Spaces** (port 7860). The Dockerfile uses `node:22-slim`, installs backend deps, copies the frontend `dist/`, runs Prisma generate, and starts the server. The frontend is served as static files by Express in production.
+
+## Key Environment Variables
+
+See `.env.example` for the full list. Critical ones:
+
+```
+HF_SPACE_MODERNFINBERT_URL   # HuggingFace Space for FinBERT
+HF_SPACE_QWEN_URL            # HuggingFace Space for Qwen3-8B
+HF_TOKEN                     # HF inference API key (fallback)
+OPENROUTER_API_KEY           # LLM fallback if HF is down
+FINNHUB_API_KEY              # News source
+TELEGRAM_BOT_TOKEN           # Alert delivery
+JWT_SECRET                   # Must be ≥32 characters
+PORT=7860                    # Required by HF Spaces
+DATABASE_URL=file:./backend/prisma/polysignal.db
+```

README.md

@@ -32,6 +32,66 @@ El backend es **totalmente funcional**:
 
 El frontend **consume datos reales del backend** y tiene **fallback a datos mock** cuando el backend no responde (modo demo sin configuracion).
 
+## Mejoras de utilidad
+
+Para que la app sea util mas alla de la demo visual, se han incorporado los siguientes ajustes — todos orientados a que las senales tengan *edge* real y no sean ruido bonito:
+
+### 1. Fetch diversificado por tag (anti-monotonia)
+
+El endpoint `/markets` de Polymarket ignora `tag_id` y siempre devuelve la home feed (politica US + World Cup). El cliente usa ahora el endpoint **`/events`** que SI respeta `tag_id`, con un catalogo curado de ~25 tags de alto valor (crypto-prices, fed, stock-market, tech, openai, middle-east, oil-industry, europe, taiwan-election, etc.) y aplana los mercados por tag.
+
+Resultado: ~1000 mercados activos diarios distribuidos en 6 categorias (cripto, economia, geopolitica, ciencia, politica, entretenimiento) en lugar de los ~100 dominados por una unica categoria.
+
+### 2. Whitelist de mercados analizables
+
+`polymarket.client.js → isAnalyzable()` flaggea como **no analizables** los mercados donde la IA no tiene edge plausible:
+
+- Predicciones de palabras (*"Will Trump say nuclear?"*)
+- Views de YouTubers, recuentos de tweets
+- "Before GTA VI"-style memes
+- Deportes y entretenimiento
+
+`signals.service.js` salta la generacion para estos mercados y el frontend pinta el badge **"FUERA DE ALCANCE"** en lugar de fabricar confianza falsa. Asi, cada senal visible es defendible.
+
+### 3. Ground truth de cripto via CoinGecko
+
+`utils/coingecko.client.js` resuelve spot prices (BTC, ETH, SOL, DOGE, ADA, XRP) y los inyecta en el prompt de la IA para mercados de precio objetivo:
+
+```
+GROUND TRUTH: BTC spot $103,400. Target $150,000 (+45.1% required).
+Use this to judge whether the implied probability is plausible given typical volatility.
+```
+
+Cache TTL 60s — respeta el rate limit gratuito de CoinGecko.
+
+### 4. Edge gap explicito (impliedProb vs fairProb)
+
+Cada `AISignal` persiste ahora `impliedProb`, `fairProb` y `edgePoints`. El pipeline mapea `(signal, confidence) → fairProb`:
+
+| Signal | Formula |
+|--------|---------|
+| bullish + conf 0.8 | fairProb = 0.5 + 0.8 × 0.5 = 0.90 |
+| bearish + conf 0.8 | fairProb = 0.5 − 0.8 × 0.5 = 0.10 |
+| neutral | fairProb = 0.5 |
+
+La tarjeta del mercado muestra: `Mercado 65% · IA 78% · Edge +13pp` — claim cuantitativo en lugar de prosa vaga.
+
+### 5. Spread-aware sizing (Kelly con costes)
+
+Polymarket expone `spread`, `bestBid`, `bestAsk` por mercado. `positions/kelly.js → suggestSize()` resta el spread del edge bruto antes de calcular el tamano de posicion:
+
+```
+edgeNeto = |edgePoints/100| - spread
+fraction = Quarter-Kelly(price, impliedProb + edgeNeto)
+amount   = bankroll * min(0.25, fraction)
+```
+
+Mercados con `spread > 5¢` se marcan como **ilíquidos** y los botones de compra se desactivan. Endpoint publico: `GET /api/v1/positions/suggestion/:marketId`.
+
+### 6. Distribucion geografica del mapa
+
+`map.js` usa **jitter determinista** (hash del marketId → desplazamiento en bounding-box del pais) para que multiples mercados del mismo pais no se apilen sobre la capital. Mercados sin pais (cripto, indices, AI) se reparten entre **40 hubs financieros** globales (NYC, Sao Paulo, Mumbai, Lagos, Moscu, Yakarta, Sydney, etc.) en vez de caer todos sobre [20,0].
+
 ## Estructura
 
 ```
@@ -183,16 +243,22 @@ El backend sigue una arquitectura **Layered (Controller → Service → Reposito
 ### Pipeline de IA
 
 ```
-Noticias (Finnhub)
+Whitelist analyzable (skip predicciones-de-palabras, sports, memes)
+    ↓
+Noticias (Finnhub) → relevantes por mercado
     ↓
 Filtrado (ModernFinBERT Space / API directa)
     ↓ (descarta neutrales, score < 0.65)
+Ground truth crypto (CoinGecko spot → solo si aplica)
+    ↓
 Generacion de senal (Qwen3-8B Space / API directa)
     ↓
 Fallback: OpenRouter (deepseek-chat)
     ↓
 Fallback: Rule-based (precio del mercado)
     ↓
+Calculo edge: impliedProb vs fairProb → edgePoints
+    ↓
 Persistencia (SQLite) + Emision Socket.io
 ```
 
@@ -200,8 +266,8 @@ Persistencia (SQLite) + Emision Socket.io
 
 | Job | Frecuencia | Descripcion |
 |-----|-----------|-------------|
-| syncMarkets | Cada 30s | Sincroniza precios desde Polymarket Gamma API |
-| generateSignals | Cada 5 min | Genera senales IA para top 20 mercados activos |
+| syncMarkets | Cada 30s | Sincroniza precios + spread desde Polymarket Gamma (fetch diversificado por tag) |
+| generateSignals | Cada 5 min | Genera senales IA para 40 mercados diversificados por categoria (solo analyzable=true) |
 | updatePositionsPnL | Cada 30s | Recalcula P&L de posiciones abiertas |
 | processAlerts | Cada 60s | Revisa watchlist y envia alertas Telegram |
 
@@ -213,9 +279,9 @@ El frontend es una SPA construida con **Vite 7** como bundler y dev server.
 
 - **Estetica dark terminal / fintech:** paleta `#0a0c10`, tipografias `Syne` + `DM Mono`.
 - **Layout ajustable:** sidebar colapsable, paneles del dashboard colapsables individualmente.
-- **Mapa global interactivo:** Leaflet con burbujas por pais (tamano = volumen, color = senal IA).
-- **Panel de senales IA:** mercados top con badges alcista/bajista/neutral y barras de probabilidad.
-- **Detalle de mercado:** sparklines, historial de precios 7d, analisis IA y simulador de posiciones.
+- **Mapa global interactivo:** Leaflet con burbujas por pais (tamano = volumen, color = senal IA), jitter determinista para evitar apilamientos y 40 hubs financieros para mercados sin pais.
+- **Panel de senales IA:** mercados con badges alcista/bajista/neutral, **fila de edge cuantitativa** (`Mercado X% · IA Y% · Edge ±N pp`) y badge **"FUERA DE ALCANCE"** para mercados no analizables.
+- **Detalle de mercado:** sparklines, historial 7d, analisis IA, simulador de posiciones con **sugerencia de tamano Quarter-Kelly cost-aware** (servida por `GET /positions/suggestion/:marketId`) y deshabilitacion automatica para mercados con spread > 5¢.
 - **Vistas adicionales:** Posiciones abiertas, Lista de seguimiento, Historial de alertas.
 
 ### Flujo de desarrollo

backend/prisma/schema.prisma

@@ -43,6 +43,11 @@ model Market {
   noPrice      Float?                         // Precio NO: 0.0 a 1.0
   volumeEur    Float?                         // Volumen en Eur
   liquidityEur Float?                         // Liquidez en Eur
+  spread       Float?                         // Bid/ask spread (0-1, ej 0.02 = 2c)
+  bestBid      Float?                         // Mejor oferta de compra
+  bestAsk      Float?                         // Mejor oferta de venta
+  clobTokenId  String?                        // YES outcome CLOB token ID (para prices-history)
+  analyzable   Boolean    @default(true)      // Si la IA tiene edge plausible aqui
   status       String     @default("active")  // active | closed | resolved
   closesAt     DateTime?                      // Fecha de cierre del mercado
   lastSynced   DateTime   @default(now())     // Ultima sincronizacion de precios
@@ -63,6 +68,9 @@ model AISignal {
   keyRisk      String?                         // 1 frase de riesgo principal
   newsCount    Int      @default(0)            // Titulares relevantes usados
   modelVersion String   @default("Qwen3-8B")   // Modelo LLM que genero la senal
+  impliedProb  Float?                          // Probabilidad implicita YES al generar (0-1)
+  fairProb     Float?                          // Probabilidad "justa" segun IA (0-1)
+  edgePoints   Float?                          // (fairProb - impliedProb) * 100, signo conserva direccion
   generatedAt  DateTime @default(now())
 
   @@index([marketId, generatedAt])

backend/src/finnhub/finnhub.service.js

@@ -2,17 +2,26 @@
  * Logica de negocio del modulo de noticias Finnhub.
  *
  * Responsabilidades:
- *   - fetchFinancialNews(daysBack)      → obtiene noticias generales de mercado.
- *   - filterNewsByRelevance(news, question) → filtra noticias por keywords
- *     extraidos de la pregunta del mercado (matching simple case-insensitive).
- *   - fetchHeadlinesForPipeline({ symbols, daysBack, limitPerSymbol })
- *     → agrega noticias de multiples simbolos para el pipeline de IA.
+ *   - fetchFinancialNewsForMarket(market) → obtiene noticias financieras
+ *     RELEVANTES para un mercado especifico de Polymarket.
+ *   - Mapeo inteligente de mercados a simbolos bursatiles (bitcoin → BTC, Coinbase, etc.)
+ *   - Deduplicacion, scoring de relevancia, y limitacion.
  *
- * Restricciones:
- *   - Si FINNHUB_API_KEY no esta configurada, devuelve array vacio sin lanzar error
- *     (el pipeline continua con rule-based).
- *   - fetchHeadlinesForPipeline limita a maximo 5 simbolos por llamada
- *     para respetar el rate limit de 60 llamadas/minuto.
+ * Filosofia:
+ *   Finnhub cubre noticias financieras. Si un mercado de Polymarket NO tiene
+ *   correlacion financiera directa (ej: GTA VI, Weinstein, deportes), NO enviamos
+ *   noticias irrelevantes de bitcoin. En esos casos, Qwen analiza solo el precio
+ *   del mercado y momentum.
+ *
+ *   Si el mercado SI tiene correlacion financiera (bitcoin, crypto, stocks, forex),
+ *   buscamos noticias especificas de los simbolos/sectores asociados usando
+ *   company-news de Finnhub para mayor precision.
+ *
+ * Mejoras:
+ *   - Cache TTL de 5 min para company-news por simbolo.
+ *   - Deduplicacion por headline normalizado.
+ *   - Maximo 8 noticias relevantes por mercado.
+ *   - Shuffle para diversidad entre mercados.
  *
  * Consumido por:
  *   - signals/aiPipeline.js → fase 1 de filtrado de noticias.
@@ -21,15 +30,242 @@
 import { getCompanyNews, getMarketNews } from './finnhub.client.js';
 import { logger } from '../utils/logger.js';
 
-const MAX_SYMBOLS_PER_PIPELINE_CALL = 5;
+const MAX_NEWS_PER_MARKET = 8;
+const NEWS_CACHE_TTL_MS = 30 * 1000; // 30 segundos (noticias frescas)
+
+// Cache por simbolo
+const companyNewsCache = new Map(); // symbol → { data, timestamp }
+const generalNewsCache = { data: null, timestamp: 0 };
+
+// ── Mapeo inteligente: mercados → simbolos financieros ────────────────────────
+
+const FINANCIAL_KEYWORDS = {
+  // Crypto
+  bitcoin: ['BTC', 'COIN', 'MSTR', 'RIOT', 'MARA'],
+  btc: ['BTC', 'COIN', 'MSTR'],
+  crypto: ['COIN', 'BTC', 'ETH', 'SOL', 'MSTR'],
+  ethereum: ['ETH', 'COIN'],
+  eth: ['ETH', 'COIN'],
+  solana: ['SOL', 'COIN'],
+  blockchain: ['COIN', 'BTC', 'IBM'],
+  altcoin: ['COIN', 'ETH', 'SOL'],
+  defi: ['COIN', 'ETH'],
+  stablecoin: ['COIN', 'CRCL'],
+
+  // Forex / Macro
+  dollar: ['DXY', 'UUP'],
+  euro: ['FXE'],
+  yen: ['FXY'],
+  pound: ['FXB'],
+  inflation: ['DXY', 'TLT', 'GLD'],
+  cpi: ['SPY', 'TLT', 'GLD'],
+  recession: ['SPY', 'QQQ', 'VIX', 'TLT'],
+  'interest rate': ['TLT', 'TBT', 'DXY'],
+  'rate cut': ['TLT', 'SPY', 'QQQ'],
+  'rate hike': ['TBT', 'DXY'],
+  fed: ['TLT', 'SPY', 'DXY'],
+  powell: ['TLT', 'SPY'],
+  ecb: ['FXE', 'EWG'],
+  boj: ['FXY', 'EWJ'],
+  unemployment: ['SPY', 'TLT'],
+  gdp: ['SPY', 'DXY'],
+  tariff: ['SPY', 'FXI', 'XLI'],
+  'trade war': ['FXI', 'SPY', 'GLD'],
+
+  // Tech / Stocks
+  apple: ['AAPL'],
+  tesla: ['TSLA'],
+  nvidia: ['NVDA'],
+  amazon: ['AMZN'],
+  google: ['GOOGL'],
+  microsoft: ['MSFT'],
+  meta: ['META'],
+  facebook: ['META'],
+  openai: ['MSFT', 'NVDA'],
+  anthropic: ['GOOGL', 'AMZN'],
+  'artificial intelligence': ['NVDA', 'MSFT', 'GOOGL', 'META'],
+  ai: ['NVDA', 'MSFT', 'GOOGL', 'META'],
+  semiconductor: ['NVDA', 'TSM', 'AVGO', 'AMD'],
+  chip: ['NVDA', 'TSM', 'AVGO', 'AMD'],
+  spacex: ['TSLA', 'RKLB'],
+  starlink: ['TSLA'],
+  boeing: ['BA'],
+  airbus: ['EADSY'],
+
+  // Commodities
+  gold: ['GLD', 'IAU'],
+  silver: ['SLV'],
+  oil: ['USO', 'XLE'],
+  energy: ['XLE', 'USO'],
+  natgas: ['UNG'],
+  uranium: ['URA', 'CCJ'],
+
+  // Market indices
+  's&p': ['SPY', 'SPX'],
+  sp500: ['SPY'],
+  nasdaq: ['QQQ'],
+  'stock market': ['SPY', 'QQQ', 'VIX'],
+  vix: ['VIX', 'SPY'],
+
+  // Geopolitical risk (afecta mercados) - elections impact VIX/DXY/defense
+  war: ['GLD', 'USO', 'DXY', 'VIX', 'LMT', 'RTX'],
+  conflict: ['GLD', 'USO', 'VIX', 'LMT'],
+  invasion: ['GLD', 'USO', 'VIX', 'LMT'],
+  ceasefire: ['SPY', 'USO'],
+  sanctions: ['USO', 'GLD', 'DXY'],
+  iran: ['USO', 'GLD', 'LMT'],
+  israel: ['USO', 'GLD', 'LMT'],
+  gaza: ['USO', 'GLD'],
+  hamas: ['USO', 'GLD'],
+  hezbollah: ['USO', 'GLD'],
+  ukraine: ['USO', 'GLD', 'LMT', 'RTX'],
+  russia: ['USO', 'GLD', 'LMT'],
+  putin: ['USO', 'GLD', 'LMT'],
+  china: ['FXI', 'USO', 'SPY'],
+  xi: ['FXI', 'SPY'],
+  taiwan: ['TSM', 'FXI', 'LMT'],
+  'north korea': ['LMT', 'EWY'],
+  venezuela: ['USO'],
+  saudi: ['USO', 'XLE'],
+  opec: ['USO', 'XLE'],
+
+  // Politica USA - mueve VIX/DXY/SPY
+  trump: ['SPY', 'DXY', 'VIX', 'XLE'],
+  biden: ['SPY', 'DXY', 'VIX'],
+  harris: ['SPY', 'VIX'],
+  desantis: ['SPY', 'XLE'],
+  vance: ['SPY', 'XLE'],
+  election: ['SPY', 'VIX', 'DXY'],
+  'presidential election': ['SPY', 'VIX', 'DXY', 'GLD'],
+  republican: ['SPY', 'XLE', 'LMT'],
+  democrat: ['SPY', 'TLT'],
+  congress: ['SPY', 'TLT'],
+  senate: ['SPY', 'TLT'],
+  shutdown: ['SPY', 'TLT', 'VIX'],
+  'debt ceiling': ['TLT', 'GLD', 'DXY'],
+  impeach: ['SPY', 'VIX'],
+  scotus: ['SPY'],
+  'supreme court': ['SPY'],
+
+  // Politica internacional
+  macron: ['EWQ', 'FXE'],
+  'le pen': ['EWQ', 'FXE'],
+  merkel: ['EWG', 'FXE'],
+  scholz: ['EWG', 'FXE'],
+  meloni: ['EWI', 'FXE'],
+  starmer: ['EWU', 'FXB'],
+  milei: ['ARGT'],
+  lula: ['EWZ'],
+  bolsonaro: ['EWZ'],
+  erdogan: ['TUR'],
+  modi: ['INDA'],
+  zelensky: ['USO', 'LMT'],
+  netanyahu: ['USO', 'GLD'],
+
+  // Entretenimiento con accionables financieros
+  netflix: ['NFLX'],
+  disney: ['DIS'],
+  marvel: ['DIS'],
+  spotify: ['SPOT'],
+  paramount: ['PARA'],
+  warner: ['WBD'],
+  'box office': ['DIS', 'WBD', 'NFLX'],
+  oscar: ['NFLX', 'DIS', 'WBD'],
+  gta: ['TTWO'],
+  rockstar: ['TTWO'],
+  'video game': ['TTWO', 'EA', 'ATVI'],
+
+  // Salud / pandemia
+  vaccine: ['PFE', 'MRNA', 'JNJ'],
+  fda: ['PFE', 'MRNA', 'LLY'],
+  pandemic: ['PFE', 'MRNA', 'VIX'],
+  'avian flu': ['PFE', 'MRNA'],
+  ozempic: ['NVO', 'LLY'],
+
+  // Clima/eventos
+  hurricane: ['XLE', 'HD', 'LOW'],
+  climate: ['ICLN', 'TAN', 'XLE'],
+};
 
 /**
- * Extrae keywords significativas de una pregunta de mercado.
- * Elimina palabras comunes (stop words) y devuelve tokens unicos.
- *
- * @param {string} question
- * @returns {string[]}
+ * Detecta si una pregunta de mercado tiene correlacion financiera
+ * y devuelve los simbolos bursatiles relevantes.
  */
+function extractFinancialSymbols(question) {
+  if (!question) return { hasFinancialCorrelation: false, symbols: [] };
+
+  const lower = question.toLowerCase();
+  const matchedSymbols = new Set();
+  const matchedKeywords = [];
+
+  for (const [keyword, symbols] of Object.entries(FINANCIAL_KEYWORDS)) {
+    // Match palabra completa o substring
+    const regex = new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b|${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'i');
+    if (regex.test(lower)) {
+      symbols.forEach((s) => matchedSymbols.add(s));
+      matchedKeywords.push(keyword);
+    }
+  }
+
+  return {
+    hasFinancialCorrelation: matchedSymbols.size > 0,
+    symbols: Array.from(matchedSymbols),
+    keywords: matchedKeywords,
+  };
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function normalizeText(text) {
+  if (!text) return '';
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function deduplicateNews(news) {
+  const seen = new Set();
+  return news.filter((item) => {
+    const normalized = normalizeText(item.headline);
+    if (!normalized || seen.has(normalized)) return false;
+    seen.add(normalized);
+    return true;
+  });
+}
+
+function shuffleArray(array) {
+  const arr = [...array];
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+
+function scoreRelevance(item, marketKeywords) {
+  if (!marketKeywords.length) return 0;
+
+  const textHeadline = normalizeText(item.headline);
+  const textSummary = normalizeText(item.summary);
+  let score = 0;
+
+  for (const kw of marketKeywords) {
+    if (textHeadline.includes(kw)) score += 3;
+    if (textSummary.includes(kw)) score += 1;
+  }
+
+  // Bonus recencia
+  if (item.datetime) {
+    const ageHours = (Date.now() - new Date(item.datetime).getTime()) / (1000 * 60 * 60);
+    if (ageHours < 6) score += 2;
+    else if (ageHours < 24) score += 1;
+  }
+
+  return score;
+}
+
 function extractKeywords(question) {
   if (!question) return [];
   const stopWords = new Set([
@@ -47,7 +283,6 @@ function extractKeywords(question) {
     'too', 'very', 'just', 'now', 'then', 'here', 'there', 'once', 'again',
     'further', 'once', 'also', 'back', 'still', 'yet', 'already', 'almost',
     'quite', 'rather', 'really', 'soon', 'today', 'tomorrow', 'yesterday',
-    // Espanol
     'el', 'la', 'los', 'las', 'un', 'una', 'unos', 'unas', 'y', 'o', 'pero',
     'en', 'de', 'a', 'por', 'para', 'con', 'sin', 'sobre', 'entre', 'durante',
     'antes', 'despues', 'durante', 'es', 'son', 'era', 'fue', 'ser', 'estar',
@@ -68,57 +303,184 @@ function extractKeywords(question) {
     .filter((w) => w.length > 2 && !stopWords.has(w));
 }
 
+// ── Cache helpers ─────────────────────────────────────────────────────────────
+
+function getCachedCompanyNews(symbol) {
+  const cached = companyNewsCache.get(symbol);
+  if (cached && Date.now() - cached.timestamp < NEWS_CACHE_TTL_MS) {
+    return cached.data;
+  }
+  return null;
+}
+
+function setCachedCompanyNews(symbol, data) {
+  companyNewsCache.set(symbol, { data, timestamp: Date.now() });
+}
+
+function getCachedGeneralNews() {
+  if (generalNewsCache.data && Date.now() - generalNewsCache.timestamp < NEWS_CACHE_TTL_MS) {
+    return generalNewsCache.data;
+  }
+  return null;
+}
+
+function setCachedGeneralNews(data) {
+  generalNewsCache.data = data;
+  generalNewsCache.timestamp = Date.now();
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
 /**
- * Filtra noticias por relevancia respecto a una pregunta de mercado.
+ * Obtiene noticias financieras RELEVANTES para un mercado especifico.
  *
- * Comprueba si alguna keyword de la pregunta aparece en el headline o summary.
- * Es case-insensitive y ignora acentos basicos.
+ * Estrategia:
+ *   1. Detecta si el mercado tiene correlacion financiera (bitcoin, crypto, etc.)
+ *   2. Si SI → busca company-news de los simbolos asociados (muy relevantes)
+ *   3. Si NO → devuelve array vacio (Qwen analizara solo el precio)
  *
- * @param {Object[]} news - Array de noticias normalizadas.
- * @param {string} question - Pregta del mercado.
- * @returns {Object[]} Noticias filtradas por relevancia.
+ * @param {Object} market - Mercado de Polymarket ({ question })
+ * @returns {Promise<Object[]>} Noticias relevantes o array vacio.
  */
-export function filterNewsByRelevance(news, question) {
-  const keywords = extractKeywords(question);
-  if (keywords.length === 0) return news;
+export async function fetchFinancialNewsForMarket(market) {
+  if (!market || !market.question) return [];
 
-  const keywordSet = new Set(keywords);
-  return news.filter((item) => {
-    const text = `${item.headline} ${item.summary}`.toLowerCase();
-    return Array.from(keywordSet).some((kw) => text.includes(kw));
+  const { hasFinancialCorrelation, symbols, keywords } = extractFinancialSymbols(market.question);
+
+  // Si NO hay correlacion financiera directa, usamos noticias macro generales
+  // como contexto (mejor que dejar a la IA sin informacion alguna).
+  if (!hasFinancialCorrelation) {
+    logger.debug({ marketId: market.id, question: market.question }, 'No financial correlation, using general macro news as context');
+    return fetchGeneralMarketNews(15);
+  }
+
+  logger.info({ marketId: market.id, symbols, keywords }, 'Fetching company news for financial market');
+
+  // Obtener noticias de cada simbolo (con cache)
+  const allNews = [];
+  // Fechas dinamicas: alternar entre 1-3 dias para variedad
+  const daysBack = 1 + Math.floor(Math.random() * 2); // 1 o 2 dias
+  
+  for (const symbol of symbols.slice(0, 5)) {
+    let news = getCachedCompanyNews(symbol);
+    if (!news) {
+      try {
+        news = await getCompanyNews(symbol, daysBack);
+        setCachedCompanyNews(symbol, news);
+      } catch (err) {
+        logger.warn({ err: err.message, symbol }, 'Failed to fetch company news');
+        news = [];
+      }
+    }
+    allNews.push(...news);
+  }
+
+  // Complementar con noticias generales del mercado para mas variedad
+  try {
+    const general = await fetchGeneralMarketNews(10);
+    allNews.push(...general);
+  } catch (e) { /* ignore */ }
+
+  // Deduplicar y ordenar por recencia
+  const deduped = deduplicateNews(allNews);
+  deduped.sort((a, b) => {
+    const da = a.datetime ? new Date(a.datetime).getTime() : 0;
+    const db = b.datetime ? new Date(b.datetime).getTime() : 0;
+    return db - da;
   });
+
+  logger.info({ marketId: market.id, count: deduped.length, symbols }, 'Company news fetched');
+  return deduped;
 }
 
 /**
- * Obtiene noticias generales de mercado de los ultimos N dias.
- *
- * @param {number} [daysBack=7]
- * @returns {Promise<Object[]>}
+ * Obtiene noticias generales de mercado (macro).
+ * Rota entre multiples categorias para variedad.
  */
-export async function fetchFinancialNews(daysBack = 7) {
-  try {
-    const general = await getMarketNews('general', 50);
-    const forex = await getMarketNews('forex', 20);
-    const crypto = await getMarketNews('crypto', 20);
-    return [...general, ...forex, ...crypto];
-  } catch (err) {
-    logger.warn({ err: err.message }, 'fetchFinancialNews failed, returning empty array');
-    return [];
+export async function fetchGeneralMarketNews(limit = 20) {
+  let news = getCachedGeneralNews();
+  if (!news) {
+    try {
+      // Rotar categorias para variedad cada vez
+      const categories = ['general', 'forex', 'crypto', 'merger'];
+      const shuffledCats = shuffleArray(categories);
+      
+      const results = await Promise.all(
+        shuffledCats.map((cat) => getMarketNews(cat, 25))
+      );
+      
+      news = deduplicateNews(results.flat());
+      news.sort((a, b) => {
+        const da = a.datetime ? new Date(a.datetime).getTime() : 0;
+        const db = b.datetime ? new Date(b.datetime).getTime() : 0;
+        return db - da;
+      });
+      setCachedGeneralNews(news);
+    } catch (err) {
+      logger.warn({ err: err.message }, 'Failed to fetch general market news');
+      return [];
+    }
   }
+  // Devolver subconjunto aleatorio para variedad entre mercados
+  return shuffleArray(news).slice(0, limit);
 }
 
 /**
- * Obtiene titulares financieros para multiples simbolos,
- * adaptados para el pipeline de procesamiento de IA.
- *
- * Limita a maximo 5 simbolos por llamada para respetar el rate limit
- * de 60 llamadas/minuto de Finnhub (free tier).
+ * Filtra noticias por relevancia respecto a una pregunta de mercado.
  *
- * @param {Object} [params={}]
- * @param {string[]} [params.symbols=[]]
- * @param {number} [params.daysBack=7]
- * @param {number} [params.limitPerSymbol=20]
- * @returns {Promise<Object[]>}
+ * @param {Object[]} news - Array de noticias normalizadas.
+ * @param {string} question - Pregunta del mercado.
+ * @returns {Object[]} Noticias filtradas por relevancia (max MAX_NEWS_PER_MARKET).
+ */
+export function filterNewsByRelevance(news, question) {
+  if (!news.length || !question) return [];
+
+  const keywords = extractKeywords(question);
+  if (keywords.length === 0) {
+    return shuffleArray(news).slice(0, MAX_NEWS_PER_MARKET);
+  }
+
+  const scored = news.map((item) => ({
+    item,
+    score: scoreRelevance(item, keywords),
+  }));
+
+  const relevant = scored
+    .filter((s) => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map((s) => s.item);
+
+  // Si hay muy pocas relevantes, complementar
+  if (relevant.length < 3) {
+    const usedIds = new Set(relevant.map((n) => n.id));
+    const extra = shuffleArray(news.filter((n) => !usedIds.has(n.id))).slice(0, MAX_NEWS_PER_MARKET - relevant.length);
+    return [...relevant, ...extra].slice(0, MAX_NEWS_PER_MARKET);
+  }
+
+  return shuffleArray(relevant.slice(0, MAX_NEWS_PER_MARKET * 2)).slice(0, MAX_NEWS_PER_MARKET);
+}
+
+/**
+ * Invalida el cache de noticias.
+ */
+export function invalidateNewsCache() {
+  companyNewsCache.clear();
+  generalNewsCache.data = null;
+  generalNewsCache.timestamp = 0;
+  logger.info('News cache invalidated');
+}
+
+/**
+ * Legacy: obtiene noticias financieras generales (sin correlacion por mercado).
+ * @deprecated Usar fetchFinancialNewsForMarket(market) en su lugar.
+ */
+export async function fetchFinancialNews() {
+  return fetchGeneralMarketNews(30);
+}
+
+/**
+ * Obtiene titulares financieros para multiples simbolos.
+ * @deprecated Usar fetchFinancialNewsForMarket(market) en su lugar.
  */
 export async function fetchHeadlinesForPipeline({
   symbols = [],
@@ -127,23 +489,14 @@ export async function fetchHeadlinesForPipeline({
 } = {}) {
   if (!symbols.length) return [];
 
-  const limitedSymbols = symbols.slice(0, MAX_SYMBOLS_PER_PIPELINE_CALL);
-  if (symbols.length > MAX_SYMBOLS_PER_PIPELINE_CALL) {
-    logger.warn(
-      { requested: symbols.length, allowed: MAX_SYMBOLS_PER_PIPELINE_CALL },
-      'fetchHeadlinesForPipeline truncated symbols to respect rate limit',
-    );
-  }
-
-  const promises = limitedSymbols.map(async (s) => {
+  const allNews = [];
+  for (const symbol of symbols.slice(0, 5)) {
     try {
-      const items = await getCompanyNews(s, daysBack);
-      return items.slice(0, limitPerSymbol).map((it) => ({ symbol: s, ...it }));
+      const items = await getCompanyNews(symbol, daysBack);
+      allNews.push(...items.slice(0, limitPerSymbol).map((it) => ({ symbol, ...it })));
     } catch (err) {
-      logger.warn({ err: err.message, symbol: s }, 'getCompanyNews failed for symbol');
-      return [];
+      logger.warn({ err: err.message, symbol }, 'getCompanyNews failed for symbol');
     }
-  });
-  const results = await Promise.all(promises);
-  return results.flat();
+  }
+  return allNews;
 }

backend/src/markets/markets.controller.js

@@ -27,4 +27,10 @@ export const marketsController = {
     const market = await marketsService.getById(req.params.id);
     ok(res, market);
   },
+
+  async getPriceHistory(req, res) {
+    const { interval } = req.query;
+    const history = await marketsService.getPriceHistory(req.params.id, interval);
+    ok(res, history);
+  },
 };

backend/src/markets/markets.repository.js

@@ -17,9 +17,12 @@ export const marketsRepository = {
   findMany({ limit, offset, category, status }) {
     const where = { status };
     if (category) where.category = category;
+    // Ordenamos por liquidez (lo realmente tradeable AHORA) y luego volumen
+    // como desempate. Esto evita que los whales politicos historicos copen
+    // siempre la primera pagina.
     return prisma.market.findMany({
       where,
-      orderBy: { volumeEur: 'desc' },
+      orderBy: [{ liquidityEur: 'desc' }, { volumeEur: 'desc' }],
       take: limit,
       skip: offset,
     });
@@ -42,4 +45,76 @@ export const marketsRepository = {
       create: market,
     });
   },
+
+  /**
+   * Marca como 'closed' los mercados activos que NO esten en la lista de IDs.
+   * Se invoca despues de un sync para purgar mercados que ya no aparecen
+   * en el fetch curado por tags (evita mostrar restos de syncs anteriores).
+   *
+   * @param {string[]} activeIds - IDs presentes en el ultimo sync.
+   * @returns {Promise<number>} Numero de mercados marcados como cerrados.
+   */
+  async deactivateStale(activeIds) {
+    const result = await prisma.market.updateMany({
+      where: {
+        id: { notIn: activeIds },
+        status: 'active',
+      },
+      data: { status: 'closed' },
+    });
+    return result.count;
+  },
+
+  /**
+   * Selecciona un conjunto diversificado de mercados activos, ponderado por
+   * liquidez+volumen y distribuido entre categorias de alto valor accionable.
+   *
+   * Categorias prioritarias (peso = numero de mercados pedidos):
+   *   - cripto, economía, geopolítica → mayor peso (mas alpha financiero)
+   *   - política, ciencia              → peso medio
+   *   - entretenimiento, deportes, general → peso bajo (relleno si sobra)
+   *
+   * @param {number} total - Numero total deseado (default 40).
+   * @returns {Promise<Market[]>}
+   */
+  async findDiversified(total = 40) {
+    const weights = {
+      'cripto': 0.20,
+      'economía': 0.18,
+      'geopolítica': 0.18,
+      'política': 0.14,
+      'ciencia': 0.12,
+      'entretenimiento': 0.08,
+      'deportes': 0.05,
+      'general': 0.05,
+    };
+
+    const slices = await Promise.all(
+      Object.entries(weights).map(async ([category, weight]) => {
+        const take = Math.max(1, Math.round(total * weight));
+        // Score: ordenamos por liquidez DESC para priorizar mercados tradeables
+        return prisma.market.findMany({
+          where: { status: 'active', category },
+          orderBy: [{ liquidityEur: 'desc' }, { volumeEur: 'desc' }],
+          take,
+        });
+      }),
+    );
+
+    const picked = slices.flat();
+    const seen = new Set(picked.map((m) => m.id));
+
+    // Si no llegamos al total (categoria vacia), rellenamos con los mas liquidos restantes
+    if (picked.length < total) {
+      const remaining = total - picked.length;
+      const filler = await prisma.market.findMany({
+        where: { status: 'active', id: { notIn: Array.from(seen) } },
+        orderBy: [{ liquidityEur: 'desc' }, { volumeEur: 'desc' }],
+        take: remaining,
+      });
+      picked.push(...filler);
+    }
+
+    return picked.slice(0, total);
+  },
 };

backend/src/markets/markets.routes.js

@@ -16,6 +16,7 @@ import { listQuery, idParam } from './markets.validators.js';
 const router = Router();
 
 router.get('/', validate(listQuery, 'query'), marketsController.list);
+router.get('/:id/history', validate(idParam, 'params'), marketsController.getPriceHistory);
 router.get('/:id', validate(idParam, 'params'), marketsController.getById);
 
 export default router;

backend/src/markets/markets.service.js

@@ -15,9 +15,20 @@
 
 import { HttpError } from '../utils/apiResponse.js';
 import { marketsRepository } from './markets.repository.js';
+import { httpGet } from '../utils/httpClient.js';
+
+const CLOB_BASE = 'https://clob.polymarket.com';
 
 export const marketsService = {
   async list(query) {
+    // Si no hay filtro de categoria y es la primera pagina, devolvemos un mix
+    // diversificado entre categorias (mejor UX que la pagina mono-categoria
+    // que sale al ordenar por liquidez DESC).
+    if (!query.category && query.offset === 0 && query.status === 'active') {
+      const diversified = await marketsRepository.findDiversified(query.limit);
+      const total = await marketsRepository.count(query);
+      return { data: diversified, total };
+    }
     const [data, total] = await Promise.all([
       marketsRepository.findMany(query),
       marketsRepository.count(query),
@@ -30,4 +41,15 @@ export const marketsService = {
     if (!market) throw new HttpError(404, 'NOT_FOUND', 'Market not found');
     return market;
   },
+
+  async getPriceHistory(id, interval = '1w') {
+    const market = await marketsRepository.findById(id);
+    if (!market) throw new HttpError(404, 'NOT_FOUND', 'Market not found');
+    if (!market.clobTokenId) throw new HttpError(404, 'NO_CLOB_TOKEN', 'Price history not available for this market');
+
+    const fidelity = interval === '1d' ? 60 : 1440;
+    const url = `${CLOB_BASE}/prices-history?market=${market.clobTokenId}&interval=${interval}&fidelity=${fidelity}`;
+    const data = await httpGet(url);
+    return data.history ?? [];
+  },
 };

backend/src/markets/markets.validators.js

@@ -12,9 +12,10 @@
 import { z } from 'zod';
 
 export const listQuery = z.object({
-  limit: z.coerce.number().int().min(1).max(100).default(20),
+  limit: z.coerce.number().int().min(1).max(200).default(60),
   offset: z.coerce.number().int().min(0).default(0),
-  category: z.enum(['politics', 'crypto', 'economics', 'sports']).optional(),
+  // Acepta cualquier categoria (las del DB estan en espanol y son dinamicas).
+  category: z.string().optional(),
   status: z.enum(['active', 'closed', 'resolved']).default('active'),
 });
 

backend/src/markets/polymarket.client.js

@@ -15,11 +15,66 @@
  */
 
 import { httpGet } from '../utils/httpClient.js';
+import { logger } from '../utils/logger.js';
 
-const GAMMA_URL = 'https://gamma-api.polymarket.com/markets';
+const GAMMA_MARKETS_URL = 'https://gamma-api.polymarket.com/markets';
+const GAMMA_EVENTS_URL = 'https://gamma-api.polymarket.com/events';
 const USD_TO_EUR = 0.93;
 
-function mapStatus({ active, closed, archived }) {
+/**
+ * Tags de Polymarket que usamos para fetching diversificado.
+ * El endpoint /markets IGNORA tag_id, pero /events lo respeta correctamente.
+ * Cada tag aporta N mercados al pool global - el weight controla cuantos.
+ *
+ * Tags verificados manualmente desde gamma-api.polymarket.com/tags.
+ */
+const TAG_SLICES = [
+  // Financieros directos (mayor peso - mas alpha)
+  { tagId: 1312, slug: 'crypto-prices', category: 'cripto', limit: 25 },
+  { tagId: 602,  slug: 'stock-market',  category: 'economía', limit: 25 },
+  { tagId: 159,  slug: 'fed',           category: 'economía', limit: 15 },
+  { tagId: 992,  slug: 'labor-market',  category: 'economía', limit: 10 },
+  { tagId: 1562, slug: 'market-caps',   category: 'economía', limit: 10 },
+
+  // Tech / AI (alta accionabilidad)
+  { tagId: 1401,   slug: 'tech',        category: 'ciencia', limit: 20 },
+  { tagId: 22,     slug: 'technology',  category: 'ciencia', limit: 15 },
+  { tagId: 101999, slug: 'big-tech',    category: 'ciencia', limit: 15 },
+  { tagId: 537,    slug: 'openai',      category: 'ciencia', limit: 10 },
+
+  // Geopolitica (afecta oil/gold/defense)
+  { tagId: 154, slug: 'middle-east',     category: 'geopolítica', limit: 20 },
+  { tagId: 78,  slug: 'iran',            category: 'geopolítica', limit: 10 },
+  { tagId: 180, slug: 'israel',          category: 'geopolítica', limit: 10 },
+  { tagId: 114, slug: 'syria',           category: 'geopolítica', limit: 10 },
+  { tagId: 172, slug: 'oil-industry',    category: 'economía', limit: 15 },
+  { tagId: 248, slug: 'energy-industry', category: 'economía', limit: 10 },
+
+  // Regional coverage (variedad geografica)
+  { tagId: 100410, slug: 'europe',     category: 'geopolítica', limit: 20 },
+  { tagId: 167,    slug: 'argentina',  category: 'geopolítica', limit: 10 },
+  { tagId: 872,    slug: 'pakistan',   category: 'geopolítica', limit: 10 },
+  { tagId: 525,    slug: 'netherlands', category: 'geopolítica', limit: 5 },
+  { tagId: 258,    slug: 'taiwan-election', category: 'geopolítica', limit: 8 },
+  { tagId: 104846, slug: 'uk-elections',    category: 'política',    limit: 8 },
+  { tagId: 103388, slug: 'thailand-election', category: 'geopolítica', limit: 5 },
+  { tagId: 104090, slug: 'french-mayoral',  category: 'política',    limit: 5 },
+  { tagId: 104968, slug: 'mexico-election', category: 'política',    limit: 8 },
+  { tagId: 103219, slug: 'bolivia-election', category: 'política',   limit: 5 },
+
+  // Politica (peso moderado - es donde hay mas volumen)
+  { tagId: 2,   slug: 'politics',          category: 'política', limit: 15 },
+  { tagId: 789, slug: 'us-politics',       category: 'política', limit: 10 },
+  { tagId: 126, slug: 'trump',             category: 'política', limit: 10 },
+
+  // Corporativo / clima / cultura
+  { tagId: 550,    slug: 'corporate-news',   category: 'economía', limit: 15 },
+  { tagId: 102890, slug: 'climate-change',   category: 'ciencia',  limit: 10 },
+  { tagId: 596,    slug: 'pop-culture',      category: 'entretenimiento', limit: 10 },
+  { tagId: 100451, slug: 'breaking',         category: 'general',  limit: 15 },
+];
+
+function mapStatus({ closed, archived }) {
   if (archived) return 'resolved';
   if (closed) return 'closed';
   return 'active';
@@ -187,28 +242,156 @@ function inferCountryCode(question, eventTitle = '') {
   return null;
 }
 
-export function mapMarket(raw) {
+/**
+ * Determina si una pregunta de mercado es analizable por la IA con edge plausible.
+ *
+ * Excluimos:
+ *   - "Will X say WORD by date" (sin base de datos predictiva)
+ *   - "Mentions" / "first to say" markets
+ *   - Mercados de views/views-counts de YouTubers
+ *   - "Before GTA VI" type meme markets
+ *
+ * Mantenemos:
+ *   - Precios objetivo (Bitcoin $X by Y)
+ *   - Decisiones Fed/ECB/BOE
+ *   - Eventos geopoliticos concretos (acuerdos, sanciones, elecciones)
+ *   - Cifras macro (CPI, GDP, employment)
+ */
+function isAnalyzable(question, category) {
+  const q = question.toLowerCase();
+
+  // Patrones de mercados NO analizables (memes, predicciones-de-palabras, views)
+  const blacklist = [
+    /\bsay\b.*\?$/i,           // "Will Trump say X?"
+    /how many.*tweet/i,         // tweets count
+    /\bmentions?\b/i,
+    /\b# of tweets\b/i,
+    /views? on day/i,           // MrBeast views
+    /views? in /i,
+    /before gta/i,              // GTA VI memes
+    /jesus christ return/i,
+    /alien/i,
+    /\bpoll(ed|ing) (above|below)/i,  // detailed polling minutiae
+    /first to/i,                // "first to reach X"
+    /wear (a|the)/i,            // clothing predictions
+    /shave/i,
+    /grammy|oscar|emmy/i,       // award shows (subjective)
+  ];
+
+  if (blacklist.some((re) => re.test(q))) return false;
+
+  // Categorias inherentemente no analizables sin modelo dedicado
+  if (category === 'deportes') return false;
+  if (category === 'entretenimiento') return false;
+
+  return true;
+}
+
+export function mapMarket(raw, { eventTitle = '', tagCategory = null } = {}) {
   const { yesPrice, noPrice } = parsePrices(raw.outcomePrices);
-  const eventTitle = raw.events?.[0]?.title || '';
+  const evTitle = eventTitle || raw.events?.[0]?.title || '';
   const question = raw.question || '';
 
+  // Prioriza categoria del tag (proviene de Polymarket directamente)
+  // sobre el matcher por keywords, que es ruidoso.
+  const category = tagCategory || inferCategory(question, evTitle);
+
+  const spread = raw.spread != null ? parseFloat(raw.spread) : null;
+  const bestBid = raw.bestBid != null ? parseFloat(raw.bestBid) : null;
+  const bestAsk = raw.bestAsk != null ? parseFloat(raw.bestAsk) : null;
+
+  let clobTokenId = null;
+  try {
+    const tokens = JSON.parse(raw.clobTokenIds || '[]');
+    clobTokenId = tokens[0] ?? null;
+  } catch { /* ignorar */ }
+
   return {
     id: String(raw.id),
     question,
-    category: inferCategory(question, eventTitle),
-    countryCode: inferCountryCode(question, eventTitle),
+    category,
+    countryCode: inferCountryCode(question, evTitle),
     yesPrice,
     noPrice,
     volumeEur: raw.volume != null ? parseFloat(raw.volume) * USD_TO_EUR : null,
     liquidityEur: raw.liquidity != null ? parseFloat(raw.liquidity) * USD_TO_EUR : null,
+    spread,
+    bestBid,
+    bestAsk,
+    clobTokenId,
+    analyzable: isAnalyzable(question, category),
     status: mapStatus(raw),
     closesAt: raw.endDate ? new Date(raw.endDate) : null,
     lastSynced: new Date(),
   };
 }
 
-export async function fetchActiveMarkets(limit = 100) {
-  const url = `${GAMMA_URL}?active=true&closed=false&limit=${limit}`;
-  const raw = await httpGet(url);
-  return raw.map(mapMarket);
+/**
+ * Obtiene eventos de Polymarket filtrados por tag_id ordenados por volumen 24h.
+ * Devuelve los markets aplanados de cada evento.
+ */
+async function fetchEventsByTag(tagId, limit) {
+  const url = `${GAMMA_EVENTS_URL}?active=true&closed=false&archived=false&tag_id=${tagId}&order=volume24hr&ascending=false&limit=${limit}`;
+  try {
+    const events = await httpGet(url);
+    if (!Array.isArray(events)) return [];
+    const flatMarkets = [];
+    for (const ev of events) {
+      const evTitle = ev.title || '';
+      for (const m of ev.markets || []) {
+        // Filtra mercados no activos a nivel de market
+        if (m.closed || m.archived || m.active === false) continue;
+        flatMarkets.push({ raw: m, eventTitle: evTitle });
+      }
+    }
+    return flatMarkets;
+  } catch (err) {
+    logger.warn({ err: err.message, tagId }, 'fetchEventsByTag failed');
+    return [];
+  }
+}
+
+/**
+ * Obtiene mercados activos de Polymarket de forma DIVERSIFICADA por tag.
+ *
+ * Problema previo: el endpoint /markets ignora tag_id y devuelve siempre la
+ * misma "home feed" de Polymarket (dominada por US politics + World Cup).
+ *
+ * Solucion: iteramos sobre el endpoint /events (que SI respeta tag_id) con
+ * una lista curada de tags de alto valor accionable (cripto, fed, tech,
+ * geopolitica, energia, etc) y aplanamos los mercados de cada evento.
+ *
+ * @returns {Promise<Market[]>} Mercados unicos con categoria asignada por tag.
+ */
+export async function fetchActiveMarkets() {
+  const results = await Promise.all(
+    TAG_SLICES.map((slice) => fetchEventsByTag(slice.tagId, slice.limit)),
+  );
+
+  // Dedup por id, preservando la categoria de la PRIMERA aparicion
+  // (los slices estan ordenados por prioridad de alpha financiero).
+  const seen = new Map(); // id → { raw, eventTitle, tagCategory }
+  results.forEach((bucket, i) => {
+    const tagCategory = TAG_SLICES[i].category;
+    for (const { raw, eventTitle } of bucket) {
+      const id = String(raw.id);
+      if (seen.has(id)) continue;
+      seen.set(id, { raw, eventTitle, tagCategory });
+    }
+  });
+
+  const mapped = Array.from(seen.values()).map(({ raw, eventTitle, tagCategory }) =>
+    mapMarket(raw, { eventTitle, tagCategory }),
+  );
+
+  // Filtro de calidad: liquidez minima 5000 EUR para excluir orderbooks muertos
+  const filtered = mapped.filter((m) => (m.liquidityEur ?? 0) >= 5000 || (m.volumeEur ?? 0) >= 50000);
+
+  logger.info({
+    totalFetched: mapped.length,
+    afterLiquidityFilter: filtered.length,
+    perCategory: filtered.reduce((acc, m) => { acc[m.category] = (acc[m.category]||0)+1; return acc; }, {}),
+  }, 'polymarket diversified fetch complete');
+
+  return filtered;
 }

backend/src/middlewares/rateLimitLogin.js

@@ -12,9 +12,11 @@
 
 import rateLimit from 'express-rate-limit';
 
+const isProd = process.env.NODE_ENV === 'production';
+
 export const rateLimitLogin = rateLimit({
   windowMs: 15 * 60 * 1000,
-  max: 5,
+  max: isProd ? 5 : 50,
   standardHeaders: true,
   legacyHeaders: false,
   message: {

backend/src/positions/kelly.js

@@ -12,9 +12,6 @@
  *
  * Devuelve:
  *   Fraccion del capital virtual recomendada (0.0 a 0.25).
- *
- * Consumido por:
- *   - positions.service.js → al abrir una posicion.
  */
 export function kellyFraction(price, pWin) {
   if (!price || price <= 0 || price >= 1 || !pWin) return 0;
@@ -23,3 +20,76 @@ export function kellyFraction(price, pWin) {
   const k = (odds * pWin - pLose) / odds;
   return Math.min(Math.max(k, 0), 0.25);
 }
+
+const SPREAD_ILLIQUID_THRESHOLD = 0.05;   // 5c bid/ask → mercado ilíquido
+const KELLY_CONSERVATIVE_FACTOR = 0.25;   // Quarter-Kelly por seguridad (LLM no calibrada)
+const MAX_BANKROLL_FRACTION = 0.25;       // No mas del 25% del bankroll por mercado
+
+/**
+ * Calcula una sugerencia de tamano de posicion *aware* del spread bid/ask.
+ *
+ * Resta el coste de ejecucion (spread) al edge bruto que reporta la IA. Si el
+ * edge neto es <= 0, devuelve 0 (no recomienda apostar). Marca ilíquidos los
+ * mercados con spread > 5c para que el frontend pueda deshabilitar el boton.
+ *
+ * @param {Object} args
+ * @param {number} args.yesPrice   precio YES actual (0-1)
+ * @param {number} args.noPrice    precio NO actual (0-1)
+ * @param {number} args.spread     bid/ask spread (0-1) reportado por Polymarket
+ * @param {Object} args.signal     { signal, confidence, edgePoints, fairProb }
+ * @param {number} [args.bankroll=1000] capital virtual base (€)
+ * @returns {{ outcome:'YES'|'NO'|null, fraction:number, amountEur:number,
+ *            edgeNet:number, illiquid:boolean, note:string }}
+ */
+export function suggestSize({ yesPrice, noPrice, spread = 0, signal, bankroll = 1000 }) {
+  const illiquid = (spread ?? 0) > SPREAD_ILLIQUID_THRESHOLD;
+
+  if (!signal || signal.edgePoints == null) {
+    return {
+      outcome: null,
+      fraction: 0,
+      amountEur: 0,
+      edgeNet: 0,
+      illiquid,
+      note: illiquid
+        ? `Mercado ilíquido (spread ${Math.round((spread ?? 0) * 100)}¢). Compra desaconsejada.`
+        : 'Sin señal IA disponible. No se puede calcular sugerencia.',
+    };
+  }
+
+  const rawEdge = Math.abs(signal.edgePoints) / 100;     // 0-1 (probabilidad)
+  const netEdge = rawEdge - (spread ?? 0);
+  const outcome = signal.edgePoints > 0 ? 'YES' : 'NO';
+  const price = outcome === 'YES' ? yesPrice : noPrice;
+
+  if (netEdge <= 0.005 || !price || price <= 0 || price >= 1) {
+    return {
+      outcome: null,
+      fraction: 0,
+      amountEur: 0,
+      edgeNet: netEdge,
+      illiquid,
+      note: illiquid
+        ? `Mercado ilíquido (spread ${Math.round((spread ?? 0) * 100)}¢).`
+        : `Sin edge neto tras spread (${(rawEdge * 100).toFixed(1)}pp − ${((spread ?? 0) * 100).toFixed(1)}pp). No apostar.`,
+    };
+  }
+
+  // Probabilidad efectiva = implied + edgeNet, capada en [0,1)
+  const pWin = Math.max(0, Math.min(0.99, price + netEdge));
+  // Quarter-Kelly por seguridad: la confianza del LLM no esta calibrada.
+  const k = kellyFraction(price, pWin) * KELLY_CONSERVATIVE_FACTOR;
+  const fraction = Math.min(MAX_BANKROLL_FRACTION, Math.max(0, k));
+  const amountEur = Math.round(bankroll * fraction);
+
+  return {
+    outcome,
+    fraction,
+    amountEur,
+    edgeNet: netEdge,
+    illiquid,
+    note: illiquid
+      ? `Mercado ilíquido (spread ${Math.round((spread ?? 0) * 100)}¢). Compra desaconsejada.`
+      : `Kelly conservador (¼) sobre edge neto ${(netEdge * 100).toFixed(1)}pp: €${amountEur} en ${outcome}.`,
+  };
+}

backend/src/positions/positions.controller.js

@@ -30,4 +30,10 @@ export const positionsController = {
     const position = await positionsService.close(req.params.id, req.user.id);
     ok(res, position);
   },
+
+  async suggest(req, res) {
+    const bankroll = req.query.bankroll ? parseFloat(req.query.bankroll) : 1000;
+    const suggestion = await positionsService.suggest(req.params.marketId, bankroll);
+    ok(res, suggestion);
+  },
 };

backend/src/positions/positions.routes.js

@@ -17,6 +17,9 @@ import { openBody, idParam, listQuery } from './positions.validators.js';
 
 const router = Router();
 
+// Endpoint publico (sugerencia de sizing) - no requiere autenticacion
+router.get('/suggestion/:marketId', positionsController.suggest);
+
 router.use(requireAuth);
 
 router.post('/', validate(openBody), positionsController.open);

backend/src/positions/positions.service.js

@@ -22,7 +22,7 @@ import { HttpError } from '../utils/apiResponse.js';
 import { positionsRepository } from './positions.repository.js';
 import { marketsRepository } from '../markets/markets.repository.js';
 import { signalsRepository } from '../signals/signals.repository.js';
-import { kellyFraction } from './kelly.js';
+import { kellyFraction, suggestSize } from './kelly.js';
 
 function currentPriceForOutcome(market, outcome) {
   return outcome === 'YES' ? market.yesPrice : market.noPrice;
@@ -80,6 +80,29 @@ export const positionsService = {
     });
   },
 
+  /**
+   * Sugiere outcome y tamano de posicion para un mercado, basado en:
+   *   - Spread bid/ask (resta del edge)
+   *   - Edge de la senal IA mas reciente (impliedProb vs fairProb)
+   *   - Quarter-Kelly capado al 25% del bankroll
+   *
+   * Devuelve { outcome, fraction, amountEur, edgeNet, illiquid, note }.
+   */
+  async suggest(marketId, bankroll = 1000) {
+    const market = await marketsRepository.findById(marketId);
+    if (!market) throw new HttpError(404, 'NOT_FOUND', 'Market not found');
+
+    const signal = await signalsRepository.findLatestByMarket(marketId);
+
+    return suggestSize({
+      yesPrice: market.yesPrice,
+      noPrice: market.noPrice,
+      spread: market.spread ?? 0,
+      signal,
+      bankroll,
+    });
+  },
+
   async updateAllPnL() {
     const open = await positionsRepository.findAllOpen();
     await Promise.all(

backend/src/scheduler.js

@@ -22,12 +22,14 @@ import { logger } from './utils/logger.js';
 
 async function syncMarkets() {
   try {
-    const markets = await fetchActiveMarkets(100);
+    const markets = await fetchActiveMarkets();
     await Promise.all(markets.map((m) => marketsRepository.upsert(m)));
+    // Purga mercados activos que no aparecieron en este sync (restos de syncs previos)
+    const deactivated = await marketsRepository.deactivateStale(markets.map((m) => m.id));
     for (const m of markets) {
       emitMarketUpdate({ marketId: m.id, yesPrice: m.yesPrice, noPrice: m.noPrice, volumeEur: m.volumeEur });
     }
-    logger.info({ count: markets.length }, 'markets synced');
+    logger.info({ count: markets.length, deactivated }, 'markets synced');
   } catch (err) {
     logger.error({ err: err.message }, 'syncMarkets failed');
   }
@@ -35,7 +37,14 @@ async function syncMarkets() {
 
 async function generateSignals() {
   try {
-    const markets = await marketsRepository.findMany({ limit: 20, offset: 0, status: 'active' });
+    // Seleccion diversificada por categoria + liquidez (40 mercados/ciclo)
+    const markets = await marketsRepository.findDiversified(40);
+    const byCategory = markets.reduce((acc, m) => {
+      acc[m.category] = (acc[m.category] || 0) + 1;
+      return acc;
+    }, {});
+    logger.info({ total: markets.length, byCategory }, 'generating signals for diversified set');
+
     for (const market of markets) {
       try {
         await signalsService.generateForMarket(market);

backend/src/signals/aiPipeline.js

@@ -21,13 +21,14 @@ import { Client } from '@gradio/client';
 import { httpPost } from '../utils/httpClient.js';
 import { config } from '../config.js';
 import { logger } from '../utils/logger.js';
-import { fetchFinancialNews, filterNewsByRelevance } from '../finnhub/finnhub.service.js';
+import { fetchFinancialNewsForMarket, filterNewsByRelevance } from '../finnhub/finnhub.service.js';
+import { analyzeCryptoTarget } from '../utils/coingecko.client.js';
 
 const HF_API = 'https://api-inference.huggingface.co/models';
 const FINBERT_MODEL = 'ProsusAI/finbert';
 const QWEN_MODEL = 'Qwen/Qwen3-8B';
 const OPENROUTER_API = 'https://openrouter.ai/api/v1/chat/completions';
-const OPENROUTER_MODEL = 'deepseek/deepseek-chat-v3-0324:free';
+const OPENROUTER_MODEL = 'deepseek/deepseek-chat';
 
 // Clientes Gradio en cache para Spaces
 let modernFinBERTClient = null;
@@ -51,19 +52,58 @@ function extractJson(text) {
   return null;
 }
 
-function buildPrompt(market, headlines) {
+function buildPrompt(market, headlines, cryptoContext = null) {
   const newsSection = headlines.length
-    ? `Relevant news:\n${headlines.map((h) => `- ${h.headline}`).join('\n')}`
-    : 'No relevant news available.';
+    ? `Recent news (use these to detect mispricing):\n${headlines.map((h) => `- ${h.headline}`).join('\n')}`
+    : 'No news available. Reason from base rates, the current implied probability, and the time-to-resolution.';
+
+  const yes = market.yesPrice;
+  const priceContext = yes != null
+    ? `Implied YES probability: ${(yes * 100).toFixed(1)}%. The market is pricing this outcome at ${yes >= 0.7 ? 'HIGH confidence YES' : yes <= 0.3 ? 'HIGH confidence NO' : 'a contested midrange'}.`
+    : 'No price available.';
+
+  // Ground truth de cripto cuando aplica
+  const cryptoSection = cryptoContext
+    ? [
+        ``,
+        `GROUND TRUTH (verified spot data):`,
+        `${cryptoContext.symbol} current spot price: $${cryptoContext.currentPrice.toLocaleString()}`,
+        `Target in question: $${cryptoContext.targetPrice.toLocaleString()}`,
+        `Required move from spot: ${cryptoContext.requiredMovePct >= 0 ? '+' : ''}${cryptoContext.requiredMovePct.toFixed(1)}%`,
+        `Use this to judge whether the implied probability is plausible given typical volatility.`,
+      ].join('\n')
+    : '';
+
+  // Tiempo hasta resolucion
+  const daysToClose = market.closesAt
+    ? Math.max(0, Math.ceil((new Date(market.closesAt) - Date.now()) / (1000 * 60 * 60 * 24)))
+    : null;
+  const timeSection = daysToClose != null
+    ? `Days until resolution: ${daysToClose}.`
+    : '';
+
   return [
-    `You are a prediction market analyst. Analyze the following market and respond ONLY with valid JSON.`,
+    `You are a sharp prediction-market trader looking for EDGE — situations where the market price diverges from the fair probability given recent information.`,
     ``,
     `Market: "${market.question}"`,
-    `YES price: ${market.yesPrice ?? 'N/A'} | NO price: ${market.noPrice ?? 'N/A'}`,
+    `Category: ${market.category ?? 'general'}`,
+    `YES price: ${yes ?? 'N/A'} | NO price: ${market.noPrice ?? 'N/A'}`,
+    priceContext,
+    timeSection,
+    cryptoSection,
+    ``,
     newsSection,
     ``,
-    `Return ONLY this JSON structure, no markdown, no explanation:`,
-    `{"signal":"bullish"|"bearish"|"neutral","confidence":<0.0-1.0>,"summary":"<2 sentences>","keyRisk":"<1 sentence>"}`,
+    `Your job is NOT to repeat what the market price says. Your job is to identify if the market is MISPRICED:`,
+    `- "bullish" = you think YES is undervalued (true probability > implied price). Higher confidence when news supports YES but price hasn't moved yet.`,
+    `- "bearish" = you think NO is undervalued (true probability < implied price). Higher confidence when news supports NO but price hasn't reacted.`,
+    `- "neutral" = market price looks fair given available information; no edge.`,
+    ``,
+    `Confidence calibration: 0.5-0.6 = weak lean, 0.6-0.75 = clear edge, 0.75-0.9 = strong conviction with concrete catalyst.`,
+    `Summary must mention WHY (specific news item or price-vs-fundamentals gap). Avoid generic statements.`,
+    ``,
+    `Return ONLY this JSON, no markdown, no explanation:`,
+    `{"signal":"bullish"|"bearish"|"neutral","confidence":<0.0-1.0>,"summary":"<2 sentences explaining the EDGE>","keyRisk":"<1 sentence: what would invalidate this thesis>"}`,
   ].join('\n');
 }
 
@@ -71,14 +111,18 @@ function buildPrompt(market, headlines) {
 
 async function getModernFinBERTClient() {
   if (!modernFinBERTClient && config.HF_SPACE_MODERNFINBERT_URL) {
-    modernFinBERTClient = await Client.connect(config.HF_SPACE_MODERNFINBERT_URL);
+    modernFinBERTClient = await Client.connect(config.HF_SPACE_MODERNFINBERT_URL, {
+      token: config.HF_TOKEN,
+    });
   }
   return modernFinBERTClient;
 }
 
 async function getQwenClient() {
   if (!qwenClient && config.HF_SPACE_QWEN_URL) {
-    qwenClient = await Client.connect(config.HF_SPACE_QWEN_URL);
+    qwenClient = await Client.connect(config.HF_SPACE_QWEN_URL, {
+      token: config.HF_TOKEN,
+    });
   }
   return qwenClient;
 }
@@ -134,7 +178,7 @@ async function filterWithFinBERT(articles) {
 
 // ── LLM generation via Space or direct API ───────────────────────────────────
 
-async function generateWithQwenSpace(market, headlines) {
+async function generateWithQwenSpace(market, headlines, cryptoContext = null) {
   const client = await getQwenClient();
   if (!client) return null;
 
@@ -142,9 +186,13 @@ async function generateWithQwenSpace(market, headlines) {
     ? headlines.map((h) => `- ${h.headline}`).join('\n')
     : 'No relevant news available.';
 
+  const cryptoLine = cryptoContext
+    ? `\nGround truth: ${cryptoContext.symbol} spot $${cryptoContext.currentPrice.toLocaleString()}, target $${cryptoContext.targetPrice.toLocaleString()} (${cryptoContext.requiredMovePct >= 0 ? '+' : ''}${cryptoContext.requiredMovePct.toFixed(1)}% required).`
+    : '';
+
   const marketContext = [
     `Market: "${market.question}"`,
-    `YES price: ${market.yesPrice ?? 'N/A'} | NO price: ${market.noPrice ?? 'N/A'}`,
+    `YES price: ${market.yesPrice ?? 'N/A'} | NO price: ${market.noPrice ?? 'N/A'}${cryptoLine}`,
   ].join('\n');
 
   const result = await client.predict('/predict', {
@@ -153,7 +201,9 @@ async function generateWithQwenSpace(market, headlines) {
   });
 
   // result.data[0] → { signal, confidence, summary, keyRisk }
-  return result.data[0];
+  const data = result.data[0];
+  if (data) data.modelVersion = 'HF Space Qwen3-8B';
+  return data;
 }
 
 async function callChatCompletion(url, model, messages, authHeader) {
@@ -165,24 +215,28 @@ async function callChatCompletion(url, model, messages, authHeader) {
   return data?.choices?.[0]?.message?.content ?? null;
 }
 
-async function generateWithQwen3Direct(market, headlines) {
+async function generateWithQwen3Direct(market, headlines, cryptoContext = null) {
   const content = await callChatCompletion(
     `${HF_API}/${QWEN_MODEL}/v1/chat/completions`,
     QWEN_MODEL,
-    [{ role: 'user', content: buildPrompt(market, headlines) }],
+    [{ role: 'user', content: buildPrompt(market, headlines, cryptoContext) }],
     `Bearer ${config.HF_TOKEN}`,
   );
-  return content ? extractJson(content) : null;
+  const data = content ? extractJson(content) : null;
+  if (data) data.modelVersion = 'HF API Qwen3-8B';
+  return data;
 }
 
-async function generateWithOpenRouter(market, headlines) {
+async function generateWithOpenRouter(market, headlines, cryptoContext = null) {
   const content = await callChatCompletion(
     OPENROUTER_API,
     OPENROUTER_MODEL,
-    [{ role: 'user', content: buildPrompt(market, headlines) }],
+    [{ role: 'user', content: buildPrompt(market, headlines, cryptoContext) }],
     `Bearer ${config.OPENROUTER_API_KEY}`,
   );
-  return content ? extractJson(content) : null;
+  const data = content ? extractJson(content) : null;
+  if (data) data.modelVersion = 'OpenRouter DeepSeek-V3';
+  return data;
 }
 
 // ── rule-based fallback ───────────────────────────────────────────────────────
@@ -195,6 +249,7 @@ function ruleBasedSignal(market) {
       confidence: Math.min(p, 0.9),
       summary: `Market strongly favors YES at ${(p * 100).toFixed(0)}% probability. Momentum is positive.`,
       keyRisk: 'Sentiment shift could rapidly reprice the market.',
+      modelVersion: 'Rule-based (price-only)',
     };
   if (p <= 0.35)
     return {
@@ -202,12 +257,14 @@ function ruleBasedSignal(market) {
       confidence: Math.min(1 - p, 0.9),
       summary: `Market strongly favors NO at ${((1 - p) * 100).toFixed(0)}% probability. Downside momentum dominates.`,
       keyRisk: 'Unexpected positive developments could reverse this rapidly.',
+      modelVersion: 'Rule-based (price-only)',
     };
   return {
     signal: 'neutral',
     confidence: 0.5,
     summary: 'Market is closely contested with no clear directional signal. Both outcomes remain plausible.',
     keyRisk: 'High uncertainty in both directions; position sizing should be conservative.',
+    modelVersion: 'Rule-based (price-only)',
   };
 }
 
@@ -236,12 +293,25 @@ function normalizeSignal(result) {
 
 // ── public API ────────────────────────────────────────────────────────────────
 
+/**
+ * Mapea (signal, confidence) → probabilidad "justa" YES segun la IA.
+ *   bullish + conf 0.8 → 0.5 + 0.8 * 0.5 = 0.9 (YES muy probable)
+ *   bearish + conf 0.8 → 0.5 - 0.8 * 0.5 = 0.1 (YES improbable)
+ *   neutral             → 0.5
+ */
+function signalToFairProbability(signal, confidence) {
+  const c = Math.max(0, Math.min(1, confidence ?? 0.5));
+  if (signal === 'bullish') return 0.5 + c * 0.5;
+  if (signal === 'bearish') return 0.5 - c * 0.5;
+  return 0.5;
+}
+
 export async function run(market) {
-  // Paso 1: obtiene y filtra noticias
+  // Paso 1: obtiene noticias financieras RELEVANTES para este mercado especifico
   let headlines = [];
   try {
-    const allNews = await fetchFinancialNews(30);
-    const relevant = filterNewsByRelevance(allNews, market.question);
+    const marketNews = await fetchFinancialNewsForMarket(market);
+    const relevant = filterNewsByRelevance(marketNews, market.question);
     if (relevant.length) {
       headlines = await filterWithFinBERT(relevant);
     } else {
@@ -251,13 +321,24 @@ export async function run(market) {
     logger.warn({ err: err.message, marketId: market.id }, 'news fetch failed, continuing without news');
   }
 
+  // Paso 1b: ground truth de cripto si aplica (BTC/ETH/SOL spot vs target)
+  let cryptoContext = null;
+  try {
+    cryptoContext = await analyzeCryptoTarget(market.question);
+    if (cryptoContext) {
+      logger.debug({ marketId: market.id, ...cryptoContext }, 'crypto ground truth injected');
+    }
+  } catch (err) {
+    logger.warn({ err: err.message }, 'crypto context fetch failed');
+  }
+
   // Paso 2: generacion de senal LLM con cadena de respaldo
   let result = null;
 
   // Intenta Space primero
   if (config.HF_SPACE_QWEN_URL) {
     try {
-      result = await generateWithQwenSpace(market, headlines);
+      result = await generateWithQwenSpace(market, headlines, cryptoContext);
       result = normalizeSignal(result);
       if (!validateSignal(result)) result = null;
     } catch (err) {
@@ -268,7 +349,7 @@ export async function run(market) {
   // Respaldo a API directa de HF
   if (!result && config.HF_TOKEN) {
     try {
-      result = await generateWithQwen3Direct(market, headlines);
+      result = await generateWithQwen3Direct(market, headlines, cryptoContext);
       if (!validateSignal(result)) result = null;
     } catch (err) {
       logger.warn({ err: err.message, marketId: market.id }, 'Qwen3 direct API failed, trying OpenRouter');
@@ -278,10 +359,10 @@ export async function run(market) {
   // Respaldo a OpenRouter
   if (!result && config.OPENROUTER_API_KEY) {
     try {
-      result = await generateWithOpenRouter(market, headlines);
+      result = await generateWithOpenRouter(market, headlines, cryptoContext);
       if (!validateSignal(result)) result = null;
     } catch (err) {
-      logger.warn({ err: err.message, marketId: market.id }, 'OpenRouter failed, using rule-based');
+      logger.warn({ err: err.message, status: err.status, marketId: market.id }, 'OpenRouter failed, using rule-based');
     }
   }
 
@@ -290,5 +371,16 @@ export async function run(market) {
     result = ruleBasedSignal(market);
   }
 
-  return { ...result, newsCount: headlines.length };
+  // Calcula edge: (fairProb - impliedProb)
+  const impliedProb = market.yesPrice ?? null;
+  const fairProb = signalToFairProbability(result.signal, result.confidence);
+  const edgePoints = impliedProb != null ? (fairProb - impliedProb) * 100 : null;
+
+  return {
+    ...result,
+    newsCount: headlines.length,
+    impliedProb,
+    fairProb,
+    edgePoints,
+  };
 }

backend/src/signals/signals.repository.js

@@ -14,9 +14,9 @@
 import { prisma } from '../utils/prisma.js';
 
 export const signalsRepository = {
-  create({ marketId, signal, confidence, summary, keyRisk, newsCount, modelVersion }) {
+  create({ marketId, signal, confidence, summary, keyRisk, newsCount, modelVersion, impliedProb, fairProb, edgePoints }) {
     return prisma.aISignal.create({
-      data: { marketId, signal, confidence, summary, keyRisk, newsCount, modelVersion },
+      data: { marketId, signal, confidence, summary, keyRisk, newsCount, modelVersion, impliedProb, fairProb, edgePoints },
     });
   },
 

backend/src/signals/signals.service.js

@@ -39,10 +39,17 @@ export const signalsService = {
   },
 
   async generateForMarket(market) {
-    const modelVersion = 'Qwen3-8B';
+    // Saltar mercados no analizables (sports, predicciones de palabras, memes).
+    // Mejor "sin senal" que confianza falsa.
+    if (market.analyzable === false) {
+      logger.debug({ marketId: market.id, question: market.question }, 'skipping non-analyzable market');
+      return null;
+    }
+
     const result = await aiPipeline.run(market);
+    const modelVersion = result.modelVersion || 'Unknown';
     const saved = await signalsRepository.create({ marketId: market.id, modelVersion, ...result });
-    emitAiSignal({ marketId: market.id, signal: saved.signal, confidence: saved.confidence, summary: saved.summary });
+    emitAiSignal({ marketId: market.id, signal: saved.signal, confidence: saved.confidence, summary: saved.summary, modelVersion: saved.modelVersion });
     logger.info({ marketId: market.id, signal: saved.signal }, 'signal generated');
     return saved;
   },

backend/src/utils/coingecko.client.js

@@ -0,0 +1,100 @@
+/**
+ * Cliente CoinGecko para spot prices de cripto.
+ *
+ * Sin API key (free tier publico). Rate limit ~30 req/min — usamos cache TTL 60s
+ * para evitar excederlo cuando hay muchos mercados de cripto en un ciclo.
+ *
+ * Consumido por:
+ *   - signals/aiPipeline.js → enriquece el prompt con ground truth para
+ *     mercados de precio objetivo (BTC $150k, ETH $5k, etc).
+ */
+
+import { httpGet } from './httpClient.js';
+import { logger } from './logger.js';
+
+const COINGECKO_URL = 'https://api.coingecko.com/api/v3/simple/price';
+const CACHE_TTL_MS = 60_000;
+
+// Mapeo symbol → id de CoinGecko
+const COIN_IDS = {
+  BTC: 'bitcoin',
+  ETH: 'ethereum',
+  SOL: 'solana',
+  DOGE: 'dogecoin',
+  XRP: 'ripple',
+  ADA: 'cardano',
+  AVAX: 'avalanche-2',
+  LINK: 'chainlink',
+  MATIC: 'matic-network',
+  DOT: 'polkadot',
+};
+
+let cache = { data: null, timestamp: 0 };
+
+async function refreshCache() {
+  const ids = Object.values(COIN_IDS).join(',');
+  const url = `${COINGECKO_URL}?ids=${ids}&vs_currencies=usd`;
+  try {
+    const data = await httpGet(url, { timeout: 8000, retries: 1 });
+    // Normaliza: { bitcoin: { usd: 103400 }, ... } → { BTC: 103400, ... }
+    const normalized = {};
+    for (const [symbol, id] of Object.entries(COIN_IDS)) {
+      if (data[id]?.usd != null) normalized[symbol] = data[id].usd;
+    }
+    cache = { data: normalized, timestamp: Date.now() };
+    return normalized;
+  } catch (err) {
+    logger.warn({ err: err.message }, 'CoinGecko fetch failed');
+    return cache.data || {};
+  }
+}
+
+/**
+ * Devuelve { BTC: 103400, ETH: 3450, SOL: 142, ... } en USD.
+ * Cache TTL 60s.
+ */
+export async function getSpotPrices() {
+  if (cache.data && Date.now() - cache.timestamp < CACHE_TTL_MS) {
+    return cache.data;
+  }
+  return refreshCache();
+}
+
+/**
+ * Detecta si una pregunta de mercado es de "precio objetivo cripto".
+ * Devuelve { symbol, targetPrice, currentPrice, requiredMovePct, deadline } o null.
+ */
+export async function analyzeCryptoTarget(question) {
+  if (!question) return null;
+
+  // Detecta symbol (BTC|Bitcoin|ETH|Ethereum|SOL|Solana)
+  const symbolMap = [
+    { rx: /\b(bitcoin|btc)\b/i, sym: 'BTC' },
+    { rx: /\b(ethereum|eth)\b/i, sym: 'ETH' },
+    { rx: /\b(solana|sol)\b/i, sym: 'SOL' },
+    { rx: /\b(dogecoin|doge)\b/i, sym: 'DOGE' },
+    { rx: /\b(xrp|ripple)\b/i, sym: 'XRP' },
+    { rx: /\b(cardano|ada)\b/i, sym: 'ADA' },
+  ];
+  const match = symbolMap.find(({ rx }) => rx.test(question));
+  if (!match) return null;
+
+  // Detecta target price ($150k, $3,500, $100,000)
+  const priceMatch = question.match(/\$\s?([\d,]+(?:\.\d+)?)\s?([kKmM])?/);
+  if (!priceMatch) return null;
+  let target = parseFloat(priceMatch[1].replace(/,/g, ''));
+  if (priceMatch[2]?.toLowerCase() === 'k') target *= 1000;
+  if (priceMatch[2]?.toLowerCase() === 'm') target *= 1_000_000;
+
+  const spots = await getSpotPrices();
+  const current = spots[match.sym];
+  if (!current || !target) return null;
+
+  const requiredMovePct = ((target - current) / current) * 100;
+  return {
+    symbol: match.sym,
+    currentPrice: current,
+    targetPrice: target,
+    requiredMovePct,
+  };
+}

frontend/dist/assets/index-D_WoXxRV.css

@@ -0,0 +1 @@
+@import "https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=Syne:wght@400;500;600;700&display=swap";:root{--bg:#0a0c10;--bg2:#111318;--bg3:#181c24;--bg4:#1e232d;--border:#ffffff14;--border2:#ffffff21;--text:#e8eaf0;--text2:#8b90a0;--text3:#7e8494;--green:#22d37a;--green2:#0d6e3a;--green3:#052a17;--red:#f04040;--red2:#7a1a1a;--red3:#2d0808;--blue:#4a9eff;--blue2:#1a4a80;--blue3:#081830;--amber:#f0a020;--amber2:#7a4e08;--amber3:#2d1c02;--accent:#4a9eff;--font-sans:"Syne", sans-serif;--font-mono:"DM Mono", monospace;--sidebar-width:240px;--sidebar-collapsed:56px;--topbar-height:56px;--panel-gap:16px;--radius:10px;--radius-sm:6px;--fs-p:clamp(1rem, 1.15vw, 1.125rem);--fs-h1:clamp(1.75rem, 2.8vw, 2.25rem);--fs-h2:clamp(1.5rem, 2.4vw, 1.875rem);--fs-h3:clamp(1.25rem, 1.9vw, 1.5rem);--fs-h4:clamp(1.125rem, 1.6vw, 1.25rem);--fs-h5:clamp(1rem, 1.3vw, 1.125rem);--fs-h6:clamp(.875rem, 1.1vw, 1rem)}*{box-sizing:border-box;margin:0;padding:0}html{font-size:16px}html,body,#app{width:100%;height:100%;overflow:hidden}body{background:var(--bg);color:var(--text);font-family:var(--font-sans);-webkit-font-smoothing:antialiased;font-size:1rem;line-height:1.5}p{font-size:var(--fs-p);line-height:1.55}h1{font-size:var(--fs-h1);font-weight:700;line-height:1.15}h2{font-size:var(--fs-h2);font-weight:700;line-height:1.2}h3{font-size:var(--fs-h3);font-weight:600;line-height:1.25}h4{font-size:var(--fs-h4);font-weight:600;line-height:1.3}h5{font-size:var(--fs-h5);font-weight:500;line-height:1.35}h6{font-size:var(--fs-h6);font-weight:500;line-height:1.4}.layout{grid-template-areas:"topbar topbar""sidebar main";grid-template-columns:var(--sidebar-width) 1fr;grid-template-rows:var(--topbar-height) 1fr;width:100vw;height:100vh;transition:grid-template-columns .25s;display:grid}.layout.collapsed{grid-template-columns:var(--sidebar-collapsed) 1fr}.sidebar{background:var(--bg2);border-right:1px solid var(--border);flex-direction:column;grid-area:sidebar;transition:width .25s;display:flex;position:relative;overflow:hidden}.sidebar-toggle{background:var(--bg3);border:1px solid var(--border2);width:24px;height:24px;color:var(--text2);cursor:pointer;z-index:10;border-radius:50%;justify-content:center;align-items:center;font-size:.875rem;transition:transform .2s;display:flex;position:absolute;top:12px;right:-10px}.layout.collapsed .sidebar-toggle{right:-10px;transform:rotate(180deg)}.topbar-logo{height:var(--topbar-height);z-index:100;align-items:center;gap:10px;display:flex;position:fixed;top:0;left:16px}.topbar-logo .logo-dot{background:var(--blue);border-radius:50%;flex-shrink:0;width:10px;height:10px;animation:2s ease-in-out infinite pulse}.topbar-logo .logo-text{color:var(--text);letter-spacing:-.3px;white-space:nowrap;font-size:1.125rem;font-weight:700}.sidebar-nav{flex-direction:column;flex:1;gap:4px;padding:14px 8px;display:flex;overflow-y:auto}.nav-item{border-radius:var(--radius-sm);cursor:pointer;color:var(--text2);white-space:nowrap;align-items:center;gap:14px;padding:14px;font-size:1rem;font-weight:500;transition:background .15s,color .15s;display:flex;overflow:hidden}.nav-item:hover{background:var(--bg3);color:var(--text)}.nav-item.active{background:var(--blue3);color:var(--blue);border:.5px solid var(--blue2)}.nav-icon{text-align:center;flex-shrink:0;width:20px;font-size:1rem}.nav-label{opacity:1;transition:opacity .15s}.layout.collapsed .nav-label{opacity:0;width:0}.sidebar-footer{border-top:1px solid var(--border);color:var(--text3);font-size:.875rem;font-family:var(--font-mono);text-align:center;white-space:nowrap;padding:14px;overflow:hidden}.layout.collapsed .sidebar-footer{opacity:0}.topbar{background:var(--bg2);border-bottom:1px solid var(--border);padding:0 16px;padding-left:calc(var(--sidebar-width) + var(--panel-gap));grid-area:topbar;align-items:center;gap:16px;display:flex;position:relative;overflow:hidden}.layout.collapsed .topbar{padding-left:calc(var(--sidebar-width) + var(--panel-gap))}.live-badge{font-family:var(--font-mono);background:var(--green3);color:var(--green);border:.5px solid var(--green2);border-radius:4px;flex-shrink:0;align-items:center;gap:4px;padding:6px 12px;font-size:.875rem;display:flex}.live-dot{background:var(--green);border-radius:50%;width:8px;height:8px;animation:1.5s ease-in-out infinite pulse}.topbar-stats{flex:1;align-items:center;gap:20px;display:flex;overflow:hidden}.stat{flex-shrink:0;align-items:center;gap:14px;display:flex}.stat-label{color:var(--text3);font-size:.875rem;font-family:var(--font-mono);text-transform:uppercase;letter-spacing:.06em}.stat-val{color:var(--text);font-size:1rem;font-weight:600;font-family:var(--font-mono)}.stat-delta{font-size:.875rem;font-family:var(--font-mono)}.stat-delta.up{color:var(--green)}.stat-delta.dn{color:var(--red)}.stat-delta.neutral{color:var(--text3)}.topbar-filters{flex-shrink:0;align-items:center;gap:10px;display:flex}.filter-select{background:var(--bg3);border:.5px solid var(--border2);border-radius:var(--radius-sm);color:var(--text);font-size:.875rem;font-family:var(--font-mono);cursor:pointer;appearance:none;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%238b90a0' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'%3E%3C/polyline%3E%3C/svg%3E");background-position:right 10px center;background-repeat:no-repeat;outline:none;min-width:140px;max-width:180px;padding:7px 30px 7px 12px;transition:border-color .15s}.filter-select:hover{border-color:var(--border2)}.filter-select:focus{border-color:var(--blue2)}.filter-select option{background:var(--bg2);color:var(--text)}.topbar-actions{flex-shrink:0;align-items:center;gap:16px;margin-left:auto;display:flex}.btn-ghost{color:var(--blue);border:.5px solid var(--blue2);background:var(--blue3);border-radius:var(--radius-sm);cursor:pointer;font-size:.9375rem;font-weight:500;font-family:var(--font-sans);padding:8px 16px;transition:opacity .15s}.btn-ghost:hover{opacity:.85}.icon-btn{background:var(--bg3);border:.5px solid var(--border2);width:32px;height:32px;color:var(--text2);cursor:pointer;border-radius:50%;justify-content:center;align-items:center;font-size:1rem;transition:color .15s,border-color .15s;display:flex}.icon-btn:hover{color:var(--text);border-color:var(--border2)}.main{padding:var(--panel-gap);background:var(--bg);grid-area:main;overflow:auto}.view{display:none}.view.active{height:100%;display:block}.dashboard-grid{gap:var(--panel-gap);grid-template-rows:minmax(120px,59%) 1fr;grid-template-columns:1fr 336px;height:100%;min-height:0;display:grid}.panel{background:var(--bg2);border:.5px solid var(--border);border-radius:var(--radius);flex-direction:column;min-height:0;display:flex;overflow:hidden}.panel-header{border-bottom:.5px solid var(--border);cursor:pointer;-webkit-user-select:none;user-select:none;justify-content:space-between;align-items:center;padding:14px;transition:background .15s;display:flex}.panel-header:hover{background:#ffffff05}.panel-title{color:var(--text3);font-size:.875rem;font-family:var(--font-mono);text-transform:uppercase;letter-spacing:.08em;align-items:center;gap:14px;display:flex}.panel-toggle{color:var(--text3);font-size:.875rem;transition:transform .2s}.panel.collapsed .panel-toggle{transform:rotate(-90deg)}.panel-body{flex:1;min-height:0;padding:12px;overflow:auto}.panel.collapsed .panel-body{display:none}.panel-subtitle{color:var(--text3);font-size:.875rem}.positions-separator{border-top:.5px solid var(--border);margin-top:10px;padding-top:10px}.panel-title.mb-sm{margin-bottom:8px}.panel.full-height{height:100%}.hidden{display:none}.desktop-only{display:initial}.mobile-only,#btn-notif,#btn-auth-mobile,.topbar-stats .legend{display:none}.map-legend{align-items:center;gap:12px;margin-left:auto;display:flex}#panel-map .panel-header{justify-content:flex-start}.map-panel{grid-area:1/1/2/2}#map-container{background:var(--bg3);border-radius:var(--radius-sm);width:100%;height:100%;min-height:300px;overflow:hidden}.signals-panel{grid-area:1/2/3/3}.signals-list{flex-direction:column;gap:16px;display:flex}.market-card{background:var(--bg3);border:.5px solid var(--border);border-radius:var(--radius-sm);cursor:pointer;padding:14px;transition:border-color .15s,background .15s}.market-card:hover{border-color:var(--border2)}.market-card.active{border-color:var(--blue2);background:var(--blue3)}.market-cat{font-size:.875rem;font-family:var(--font-mono);color:var(--text3);text-transform:uppercase;letter-spacing:.06em;margin-bottom:4px}.market-q{color:var(--text);margin-bottom:8px;font-size:.9375rem;font-weight:500;line-height:1.4}.market-footer{justify-content:space-between;align-items:center;gap:16px;display:flex}.prob-bar-wrap{flex:1;min-width:0}.prob-bar-bg{background:var(--bg4);border-radius:2px;height:5px;overflow:hidden}.prob-bar-fill{height:100%;width:var(--prob-width,0%);border-radius:2px;transition:width .8s}.prob-val{font-size:.9375rem;font-weight:600;font-family:var(--font-mono);flex-shrink:0}.signal-badge{font-size:.875rem;font-weight:600;font-family:var(--font-mono);letter-spacing:.04em;border-radius:4px;flex-shrink:0;padding:2px 6px}.sig-bull{background:var(--green3);color:var(--green);border:.5px solid var(--green2)}.sig-bear{background:var(--red3);color:var(--red);border:.5px solid var(--red2)}.sig-neut{background:var(--bg4);color:var(--text2);border:.5px solid var(--border2)}.sig-none{color:var(--text3,#6e7681);border:.5px dashed var(--border2);letter-spacing:.06em;background:0 0;font-size:.72rem;font-weight:500}.spread-badge{color:var(--text3,#6e7681);font-size:.7rem;font-family:var(--font-mono);margin-left:6px}.spread-badge.illiquid{color:var(--red,#f04040);font-weight:600}.edge-row{border-top:.5px solid var(--border2,#1f242b);font-size:.72rem;font-family:var(--font-mono);letter-spacing:.02em;align-items:center;gap:6px;margin-top:6px;padding-top:6px;display:flex}.edge-implied{color:var(--text2,#9aa4b2)}.edge-fair{font-weight:600}.edge-sep{color:var(--text3,#4a5260);opacity:.6}.edge-value{border-radius:3px;padding:1px 5px;font-weight:700}.edge-pos{color:var(--green,#22d37a);background:var(--green3,#22d37a14)}.edge-neg{color:var(--red,#f04040);background:var(--red3,#f0404014)}.edge-zero{color:var(--text3,#6e7681)}.kelly-note{color:var(--text2,#9aa4b2);font-size:.78rem;font-family:var(--font-mono);border-left:2px solid var(--border2,#1f242b);background:#ffffff05;border-radius:0 4px 4px 0;flex:1;padding:4px 8px}.kelly-warn{color:var(--red,#f04040);border-left-color:var(--red,#f04040);background:#f040400d}.detail-panel{grid-area:2/1/3/2;overflow:hidden}.detail-panel .panel-body{overflow:hidden}.detail-panel .panel-body>div{flex-direction:column;gap:10px;height:100%;min-height:0;display:flex}.detail-header{justify-content:space-between;align-items:flex-start;gap:16px;margin-bottom:12px;display:flex}.detail-tag{color:var(--blue);font-size:.875rem;font-family:var(--font-mono);text-transform:uppercase;letter-spacing:.08em;margin-bottom:4px}.detail-q{color:var(--text);font-size:1rem;font-weight:600;line-height:1.5}.detail-meta{color:var(--text3);font-size:.875rem;font-family:var(--font-mono);margin-top:2px}.detail-metrics{flex-shrink:0;align-items:center;gap:16px;display:flex}.metric{text-align:right}.metric-label{color:var(--text3);font-size:.875rem;font-family:var(--font-mono);margin-bottom:2px}.metric-value{font-size:.875rem;font-weight:700;font-family:var(--font-mono)}.metric-sep{background:var(--border);width:1px;height:40px}.outcomes-row{flex:1;gap:16px;min-height:0;display:flex}.outcome-card{background:var(--bg3);border:.5px solid var(--border);border-radius:var(--radius-sm);text-align:center;flex:1;padding:14px}.outcome-name{color:var(--text2);font-size:.875rem;font-family:var(--font-mono);margin-bottom:4px}.outcome-price{color:var(--text);font-size:1.25rem;font-weight:700;font-family:var(--font-mono)}.outcome-delta{font-size:.875rem;font-family:var(--font-mono);margin-top:2px}.outcome-card.yes .outcome-price{color:var(--green)}.outcome-card.no .outcome-price{color:var(--red)}.chart-container{background:var(--bg3);border:.5px solid var(--border);border-radius:var(--radius-sm);flex:2;align-self:stretch;min-height:80px;padding:14px;overflow:hidden}.chart-label{color:var(--text3);font-size:.875rem;font-family:var(--font-mono);margin-bottom:6px}.outcome-mini{flex-direction:column;align-items:center;gap:2px;padding:0 10px;display:flex}.outcome-mini-label{font-size:.72rem;font-family:var(--font-mono);color:var(--text3);text-transform:uppercase;letter-spacing:.06em}.outcome-mini-price{font-size:1rem;font-weight:700;font-family:var(--font-mono)}.outcome-mini-price.yes{color:var(--green)}.outcome-mini-price.no{color:var(--red)}.ai-box{background:var(--bg3);border:.5px solid var(--blue2);border-radius:var(--radius-sm);flex:1;align-items:flex-start;gap:14px;min-width:0;padding:14px;display:flex;overflow:hidden}.ai-icon{background:var(--blue3);border-radius:6px;flex-shrink:0;justify-content:center;align-items:center;width:32px;height:32px;font-size:.875rem;display:flex}.ai-label{color:var(--blue);font-size:.875rem;font-family:var(--font-mono);text-transform:uppercase;letter-spacing:.06em;margin-bottom:3px}.ai-text{color:var(--text2);font-size:.9375rem;line-height:1.5}.sim-row{flex-wrap:wrap;justify-content:flex-end;align-items:center;gap:16px;display:flex}.sim-label{color:var(--text3);font-size:.9375rem;font-family:var(--font-mono)}.sim-input{background:var(--bg3);border:.5px solid var(--border2);border-radius:var(--radius-sm);color:var(--text);font-size:1rem;font-family:var(--font-mono);outline:none;width:100px;padding:8px 14px}.sim-input:focus{border-color:var(--blue2)}.sim-btn-yes{background:var(--green3);border:.5px solid var(--green2);color:var(--green);border-radius:var(--radius-sm);cursor:pointer;font-size:.9375rem;font-weight:600;font-family:var(--font-mono);padding:8px 16px;transition:opacity .15s}.sim-btn-no{background:var(--red3);border:.5px solid var(--red2);color:var(--red);border-radius:var(--radius-sm);cursor:pointer;font-size:.9375rem;font-weight:600;font-family:var(--font-mono);padding:8px 16px;transition:opacity .15s}.sim-btn-yes:hover,.sim-btn-no:hover{opacity:.85}.sim-disclaimer{color:var(--text3);font-size:.875rem;font-family:var(--font-mono)}.legend{align-items:center;gap:16px;display:flex}.legend-item{color:var(--text3);font-size:.875rem;font-family:var(--font-mono);align-items:center;gap:5px;display:flex}.legend-dot{border-radius:50%;width:10px;height:10px}.legend-dot.green{background:var(--green)}.legend-dot.red{background:var(--red)}.legend-dot.gray{background:var(--text3)}.legend.end{margin-left:auto}.table-wrap{border:.5px solid var(--border);border-radius:var(--radius-sm);background:var(--bg3);overflow:auto}table{border-collapse:collapse;width:100%;font-size:1rem}th,td{text-align:left;border-bottom:.5px solid var(--border);padding:14px}th{font-family:var(--font-mono);color:var(--text3);text-transform:uppercase;letter-spacing:.06em;background:var(--bg4);font-size:.875rem;font-weight:500;position:sticky;top:0}tr:hover td{background:#ffffff05}td{color:var(--text)}.td-mono{font-family:var(--font-mono)}.td-green{color:var(--green)}.td-red{color:var(--red)}.td-blue{color:var(--blue)}.empty-state{text-align:center;color:var(--text3);padding:40px;font-size:1rem}#app .leaflet-container{background:var(--bg3);font-family:var(--font-mono)}#app .leaflet-popup-content-wrapper{background:var(--bg2);color:var(--text);border:.5px solid var(--border);border-radius:var(--radius-sm)}#app .leaflet-popup-tip{background:var(--bg2)}.sparkline{align-items:flex-end;gap:2px;height:32px;margin-top:6px;display:flex}.spark-bar{background:var(--blue2);border-radius:1px;width:3px;transition:height .3s}@keyframes pulse{0%,to{opacity:1}50%{opacity:.4}}@keyframes scroll-stats{0%{transform:translate(0)}to{transform:translate(-50%)}}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:var(--bg4);border-radius:3px}::-webkit-scrollbar-thumb:hover{background:var(--text3)}.flex-between{justify-content:space-between;align-items:center;display:flex}.flex-start{justify-content:space-between;align-items:flex-start;display:flex}.flex-row{align-items:center;display:flex}.flex-wrap{flex-wrap:wrap}.gap-6{gap:14px}.gap-8{gap:16px}.text-green{color:var(--green)}.text-red{color:var(--red)}.text-blue{color:var(--blue)}.text-amber{color:var(--amber)}.text-neutral{color:var(--text3)}.bg-green{background:var(--green)}.bg-red{background:var(--red)}.bg-amber{background:var(--amber)}.flex-1{flex:1}.font-mono{font-family:var(--font-mono)}.text-xs,.text-sm{font-size:.875rem}.text-base{font-size:.9375rem}.text-lg{font-size:1rem}.text-xl{font-size:1.125rem}.font-semibold{font-weight:600}.font-bold{font-weight:700}.mb-4{margin-bottom:4px}.mb-6{margin-bottom:6px}.mb-8{margin-bottom:8px}.mt-4{margin-top:4px}.mt-6{margin-top:6px}.ml-auto{margin-left:auto}.divider{background:var(--border);height:1px;margin:8px 0}.empty-state-sm{text-align:center;color:var(--text3);padding:16px;font-size:1rem}.map-popup{font-family:var(--font-sans);color:var(--text);max-width:200px;font-size:.9375rem}.map-popup-cat{color:var(--text3);font-size:.875rem;font-family:var(--font-mono);text-transform:uppercase;margin-bottom:4px}.map-popup-q{margin-bottom:4px;font-weight:600;line-height:1.3}.map-popup-prices{font-family:var(--font-mono);gap:16px;font-size:.9375rem;display:flex}.map-label-text{color:var(--text2);font-family:var(--font-mono);text-shadow:0 1px 2px #000;font-size:.875rem}.modal-overlay{-webkit-backdrop-filter:blur(4px);backdrop-filter:blur(4px);z-index:1000;opacity:1;background:#000000b3;justify-content:center;align-items:center;transition:opacity .2s;display:flex;position:fixed;inset:0}.modal-overlay.hidden{display:none}.modal{background:var(--bg2);border:.5px solid var(--border);border-radius:var(--radius);width:100%;max-width:420px;overflow:hidden}.modal-header{border-bottom:.5px solid var(--border);justify-content:space-between;align-items:center;padding:16px 20px;display:flex}.modal-tabs{gap:4px;display:flex}.modal-tab{color:var(--text2);font-family:var(--font-sans);border-radius:var(--radius-sm);cursor:pointer;background:0 0;border:none;padding:8px 16px;font-size:.9375rem;font-weight:500;transition:background .15s,color .15s}.modal-tab:hover{color:var(--text)}.modal-tab.active{background:var(--bg3);color:var(--text)}.modal-close{color:var(--text2);cursor:pointer;border-radius:var(--radius-sm);background:0 0;border:none;justify-content:center;align-items:center;width:32px;height:32px;font-size:1.125rem;transition:background .15s,color .15s;display:flex}.modal-close:hover{background:var(--bg3);color:var(--text)}.modal-body{padding:20px}.modal-form{flex-direction:column;gap:16px;display:none}.modal-form.active{display:flex}.form-group{flex-direction:column;gap:6px;display:flex}.form-group label{color:var(--text2);font-size:.875rem;font-family:var(--font-mono);text-transform:uppercase;letter-spacing:.06em}.form-group input{background:var(--bg3);border:.5px solid var(--border2);border-radius:var(--radius-sm);color:var(--text);font-size:.9375rem;font-family:var(--font-sans);outline:none;padding:12px 14px;transition:border-color .15s}.form-group input:focus{border-color:var(--blue2)}.form-group input::placeholder{color:var(--text3)}.form-error{color:var(--red);font-size:.875rem;font-family:var(--font-mono);min-height:18px}.modal-submit{color:#fff;font-family:var(--font-sans);border-radius:var(--radius-sm);cursor:pointer;background:#2563eb;border:none;margin-top:4px;padding:12px;font-size:.9375rem;font-weight:600;transition:opacity .15s}.modal-submit:hover{opacity:.9}.modal-title{color:var(--text);align-items:center;gap:10px;font-size:1rem;font-weight:600;display:flex}.modal-title-icon{font-size:1.125rem}.form-hint{color:var(--text3);font-size:.8125rem;line-height:1.4}.form-hint a{color:var(--blue);text-decoration:none}.form-hint a:hover{text-decoration:underline}.toggle-row{justify-content:space-between;align-items:center;display:flex}.toggle-switch{cursor:pointer;width:44px;height:24px;display:inline-block;position:relative}.toggle-switch input{opacity:0;width:0;height:0}.toggle-slider{background:var(--bg4);border:.5px solid var(--border);border-radius:24px;transition:background .2s;position:absolute;inset:0}.toggle-slider:before{content:"";background:var(--text2);border-radius:50%;width:18px;height:18px;transition:transform .2s,background .2s;position:absolute;bottom:2px;left:2px}.toggle-switch input:checked+.toggle-slider{background:var(--blue2);border-color:var(--blue)}.toggle-switch input:checked+.toggle-slider:before{background:var(--text);transform:translate(20px)}.form-status{font-size:.875rem;font-family:var(--font-mono);min-height:18px;color:var(--text2)}.form-status.success{color:var(--green)}.form-status.error{color:var(--red)}.form-actions{gap:10px;margin-top:4px;display:flex}.modal-submit--secondary{background:var(--bg3);color:var(--text);border:.5px solid var(--border2)}.modal-submit--secondary:hover{background:var(--bg4);opacity:1}.telegram-instructions{border-bottom:.5px solid var(--border);flex-direction:column;gap:12px;margin-bottom:20px;padding-bottom:16px;display:flex}.instruction-step{align-items:flex-start;gap:12px;display:flex}.step-num{background:var(--blue3);width:24px;height:24px;color:var(--blue);border-radius:50%;flex-shrink:0;justify-content:center;align-items:center;margin-top:2px;font-size:.8125rem;font-weight:600;display:flex}.step-body{flex:1}.step-body strong{color:var(--text);margin-bottom:2px;font-size:.875rem;font-weight:600;display:block}.step-body p{color:var(--text2);margin:0;font-size:.8125rem;line-height:1.5}.step-body a{color:var(--blue);text-decoration:none}.step-body a:hover{text-decoration:underline}.step-body code{background:var(--bg3);font-family:var(--font-mono);color:var(--text);border-radius:4px;padding:1px 5px;font-size:.75rem}.auth-indicator{background:var(--bg3);border:.5px solid var(--border2);width:32px;height:32px;color:var(--text2);cursor:pointer;border-radius:50%;flex-shrink:0;justify-content:center;align-items:center;padding:0;transition:color .15s,border-color .15s,background .2s;display:flex}.auth-indicator:after{content:"";background:var(--red);border-radius:50%;width:8px;height:8px;transition:background .2s;display:block}.auth-indicator.logged-in:after{background:var(--green)}.stats-track{flex:1;align-items:center;gap:20px;display:flex}.stats-track .legend.end~.stat,.stats-track .legend.end~.legend{display:none}.signals-sentinel{text-align:center;color:var(--text3);font-family:var(--font-mono);padding:12px;font-size:.875rem}#filter-trend{background:var(--bg3);border:.5px solid var(--amber2);min-width:170px;color:var(--amber)}#filter-trend:focus{border-color:var(--amber)}#filter-trend option{background:var(--bg2);color:var(--text)}.trend-badge{font-size:.75rem;font-weight:600;font-family:var(--font-mono);letter-spacing:.04em;border-radius:4px;margin-left:8px;padding:2px 6px}.trend-hot{color:var(--amber);border:.5px solid var(--amber2);background:#f0a02026}.trend-bull{background:var(--green3);color:var(--green);border:.5px solid var(--green2)}.trend-bear{background:var(--red3);color:var(--red);border:.5px solid var(--red2)}.trend-volatile{color:var(--blue);border:.5px solid var(--blue2);background:#4a9eff26}@media (width<=1024px){*{scrollbar-width:none;-ms-overflow-style:none}::-webkit-scrollbar{display:none}.dashboard-grid{grid-template-rows:auto auto auto;grid-template-columns:1fr}.signals-panel{grid-area:auto;max-height:400px}.map-panel{grid-area:auto;min-height:300px}.detail-panel{grid-area:auto}}@media (width<=640px){.layout{grid-template-rows:auto 1fr;grid-template-columns:0 1fr}.sidebar{display:none}.detail-header{flex-direction:column;gap:8px;margin-bottom:8px}.detail-metrics{justify-content:flex-start;width:100%}.metric{text-align:left}.outcomes-row{grid-template-columns:1fr 1fr;gap:10px;margin-bottom:10px;display:grid}.outcomes-row .chart-container{grid-column:1/-1;height:130px;min-height:0;max-height:130px}.sim-row{grid-template-columns:1fr auto auto;align-items:center;gap:8px;display:grid}.sim-row .sim-label{grid-column:1/-1;font-size:.875rem}.sim-row .sim-input{width:100%;min-width:0}.sim-row .sim-btn-yes,.sim-row .sim-btn-no{white-space:nowrap;padding:8px 12px;font-size:.875rem}.sim-row .sim-disclaimer{grid-column:1/-1;font-size:.75rem}.desktop-only{display:none!important}.mobile-only{display:initial}.topbar{flex-wrap:wrap;gap:8px;height:auto;min-height:auto;padding:8px 12px}.topbar-logo{flex:1;order:0;height:auto;position:static}.topbar-actions{order:0;gap:10px;margin-left:0}.topbar-stats{flex:none;order:1;align-items:center;width:100%;display:flex;overflow:hidden}.topbar-stats .live-badge{display:none}.stats-track{flex:none;align-items:center;gap:24px;width:max-content;animation:20s linear infinite scroll-stats;display:flex;-webkit-mask-image:linear-gradient(90deg,#0000,#000 8% 92%,#0000);mask-image:linear-gradient(90deg,#0000,#000 8% 92%,#0000)}.stats-track:hover{animation-play-state:paused}.topbar-stats .stat{flex-shrink:0;gap:8px;padding:4px 0}.topbar-stats .stat-label{font-size:.75rem}.topbar-stats .stat-val{font-size:.875rem}.topbar-stats .stat-delta{font-size:.75rem}.topbar-stats .legend{display:none}.stats-track .legend.end~.stat{display:flex}.dashboard-grid{height:auto}.map-panel{min-height:250px}.signals-panel{max-height:none}.panel.collapsed{min-height:0;max-height:none}#btn-telegram-mobile{color:var(--blue);background:var(--blue3);border-color:var(--blue2)}#btn-notif,#btn-auth-mobile{display:flex}.topbar-logo .logo-text{font-size:1rem}#panel-map .panel-header{flex-wrap:wrap;gap:6px 0}#panel-map .panel-title{flex:1}.map-legend{order:1;justify-content:flex-end;width:100%;margin:0}#panel-signals .panel-header{z-index:10;background:var(--bg2);position:sticky;top:0}#panel-detail{display:none}.market-card-detail{background:var(--bg3);border:.5px solid var(--blue2);border-radius:var(--radius-sm);flex-direction:column;gap:12px;padding:14px;display:flex}}.leaflet-pane,.leaflet-tile,.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-tile-container,.leaflet-pane>svg,.leaflet-pane>canvas,.leaflet-zoom-box,.leaflet-image-layer,.leaflet-layer{position:absolute;top:0;left:0}.leaflet-container{overflow:hidden}.leaflet-tile,.leaflet-marker-icon,.leaflet-marker-shadow{-webkit-user-select:none;user-select:none;-webkit-user-drag:none}.leaflet-tile::selection{background:0 0}.leaflet-safari .leaflet-tile{image-rendering:-webkit-optimize-contrast}.leaflet-safari .leaflet-tile-container{-webkit-transform-origin:0 0;width:1600px;height:1600px}.leaflet-marker-icon,.leaflet-marker-shadow{display:block}.leaflet-container .leaflet-overlay-pane svg{max-width:none!important;max-height:none!important}.leaflet-container .leaflet-marker-pane img,.leaflet-container .leaflet-shadow-pane img,.leaflet-container .leaflet-tile-pane img,.leaflet-container img.leaflet-image-layer,.leaflet-container .leaflet-tile{width:auto;padding:0;max-width:none!important;max-height:none!important}.leaflet-container img.leaflet-tile{mix-blend-mode:plus-lighter}.leaflet-container.leaflet-touch-zoom{-ms-touch-action:pan-x pan-y;touch-action:pan-x pan-y}.leaflet-container.leaflet-touch-drag{-ms-touch-action:pinch-zoom;touch-action:none;touch-action:pinch-zoom}.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom{-ms-touch-action:none;touch-action:none}.leaflet-container{-webkit-tap-highlight-color:transparent}.leaflet-container a{-webkit-tap-highlight-color:#33b5e566}.leaflet-tile{filter:inherit;visibility:hidden}.leaflet-tile-loaded{visibility:inherit}.leaflet-zoom-box{box-sizing:border-box;z-index:800;width:0;height:0}.leaflet-overlay-pane svg{-moz-user-select:none}.leaflet-pane{z-index:400}.leaflet-tile-pane{z-index:200}.leaflet-overlay-pane{z-index:400}.leaflet-shadow-pane{z-index:500}.leaflet-marker-pane{z-index:600}.leaflet-tooltip-pane{z-index:650}.leaflet-popup-pane{z-index:700}.leaflet-map-pane canvas{z-index:100}.leaflet-map-pane svg{z-index:200}.leaflet-vml-shape{width:1px;height:1px}.lvml{behavior:url(#default#VML);display:inline-block;position:absolute}.leaflet-control{z-index:800;pointer-events:visiblePainted;pointer-events:auto;position:relative}.leaflet-top,.leaflet-bottom{z-index:1000;pointer-events:none;position:absolute}.leaflet-top{top:0}.leaflet-right{right:0}.leaflet-bottom{bottom:0}.leaflet-left{left:0}.leaflet-control{float:left;clear:both}.leaflet-right .leaflet-control{float:right}.leaflet-top .leaflet-control{margin-top:10px}.leaflet-bottom .leaflet-control{margin-bottom:10px}.leaflet-left .leaflet-control{margin-left:10px}.leaflet-right .leaflet-control{margin-right:10px}.leaflet-fade-anim .leaflet-popup{opacity:0;transition:opacity .2s linear}.leaflet-fade-anim .leaflet-map-pane .leaflet-popup{opacity:1}.leaflet-zoom-animated{transform-origin:0 0}svg.leaflet-zoom-animated{will-change:transform}.leaflet-zoom-anim .leaflet-zoom-animated{-webkit-transition:-webkit-transform .25s cubic-bezier(0,0,.25,1);-moz-transition:-moz-transform .25s cubic-bezier(0,0,.25,1);transition:transform .25s cubic-bezier(0,0,.25,1)}.leaflet-zoom-anim .leaflet-tile,.leaflet-pan-anim .leaflet-tile{transition:none}.leaflet-zoom-anim .leaflet-zoom-hide{visibility:hidden}.leaflet-interactive{cursor:pointer}.leaflet-grab{cursor:-webkit-grab;cursor:-moz-grab;cursor:grab}.leaflet-crosshair,.leaflet-crosshair .leaflet-interactive{cursor:crosshair}.leaflet-popup-pane,.leaflet-control{cursor:auto}.leaflet-dragging .leaflet-grab,.leaflet-dragging .leaflet-grab .leaflet-interactive,.leaflet-dragging .leaflet-marker-draggable{cursor:move;cursor:-webkit-grabbing;cursor:-moz-grabbing;cursor:grabbing}.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-image-layer,.leaflet-pane>svg path,.leaflet-tile-container{pointer-events:none}.leaflet-marker-icon.leaflet-interactive,.leaflet-image-layer.leaflet-interactive,.leaflet-pane>svg path.leaflet-interactive,svg.leaflet-image-layer.leaflet-interactive path{pointer-events:visiblePainted;pointer-events:auto}.leaflet-container{outline-offset:1px;background:#ddd}.leaflet-container a{color:#0078a8}.leaflet-zoom-box{background:#ffffff80;border:2px dotted #38f}.leaflet-container{font-family:Helvetica Neue,Arial,Helvetica,sans-serif;font-size:.75rem;line-height:1.5}.leaflet-bar{border-radius:4px;box-shadow:0 1px 5px #000000a6}.leaflet-bar a{text-align:center;color:#000;background-color:#fff;border-bottom:1px solid #ccc;width:26px;height:26px;line-height:26px;text-decoration:none;display:block}.leaflet-bar a,.leaflet-control-layers-toggle{background-position:50%;background-repeat:no-repeat;display:block}.leaflet-bar a:hover,.leaflet-bar a:focus{background-color:#f4f4f4}.leaflet-bar a:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.leaflet-bar a:last-child{border-bottom:none;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.leaflet-bar a.leaflet-disabled{cursor:default;color:#bbb;background-color:#f4f4f4}.leaflet-touch .leaflet-bar a{width:30px;height:30px;line-height:30px}.leaflet-touch .leaflet-bar a:first-child{border-top-left-radius:2px;border-top-right-radius:2px}.leaflet-touch .leaflet-bar a:last-child{border-bottom-right-radius:2px;border-bottom-left-radius:2px}.leaflet-control-zoom-in,.leaflet-control-zoom-out{text-indent:1px;font:700 18px Lucida Console,Monaco,monospace}.leaflet-touch .leaflet-control-zoom-in,.leaflet-touch .leaflet-control-zoom-out{font-size:22px}.leaflet-control-layers{background:#fff;border-radius:5px;box-shadow:0 1px 5px #0006}.leaflet-control-layers-toggle{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABoAAAAaCAQAAAADQ4RFAAACf0lEQVR4AY1UM3gkARTePdvdoTxXKc+qTl3aU5U6b2Kbkz3Gtq3Zw6ziLGNPzrYx7946Tr6/ee/XeCQ4D3ykPtL5tHno4n0d/h3+xfuWHGLX81cn7r0iTNzjr7LrlxCqPtkbTQEHeqOrTy4Yyt3VCi/IOB0v7rVC7q45Q3Gr5K6jt+3Gl5nCoDD4MtO+j96Wu8atmhGqcNGHObuf8OM/x3AMx38+4Z2sPqzCxRFK2aF2e5Jol56XTLyggAMTL56XOMoS1W4pOyjUcGGQdZxU6qRh7B9Zp+PfpOFlqt0zyDZckPi1ttmIp03jX8gyJ8a/PG2yutpS/Vol7peZIbZcKBAEEheEIAgFbDkz5H6Zrkm2hVWGiXKiF4Ycw0RWKdtC16Q7qe3X4iOMxruonzegJzWaXFrU9utOSsLUmrc0YjeWYjCW4PDMADElpJSSQ0vQvA1Tm6/JlKnqFs1EGyZiFCqnRZTEJJJiKRYzVYzJck2Rm6P4iH+cmSY0YzimYa8l0EtTODFWhcMIMVqdsI2uiTvKmTisIDHJ3od5GILVhBCarCfVRmo4uTjkhrhzkiBV7SsaqS+TzrzM1qpGGUFt28pIySQHR6h7F6KSwGWm97ay+Z+ZqMcEjEWebE7wxCSQwpkhJqoZA5ivCdZDjJepuJ9IQjGGUmuXJdBFUygxVqVsxFsLMbDe8ZbDYVCGKxs+W080max1hFCarCfV+C1KATwcnvE9gRRuMP2prdbWGowm1KB1y+zwMMENkM755cJ2yPDtqhTI6ED1M/82yIDtC/4j4BijjeObflpO9I9MwXTCsSX8jWAFeHr05WoLTJ5G8IQVS/7vwR6ohirYM7f6HzYpogfS3R2OAAAAAElFTkSuQmCC);width:36px;height:36px}.leaflet-retina .leaflet-control-layers-toggle{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADQAAAA0CAQAAABvcdNgAAAEsklEQVR4AWL4TydIhpZK1kpWOlg0w3ZXP6D2soBtG42jeI6ZmQTHzAxiTbSJsYLjO9HhP+WOmcuhciVnmHVQcJnp7DFvScowZorad/+V/fVzMdMT2g9Cv9guXGv/7pYOrXh2U+RRR3dSd9JRx6bIFc/ekqHI29JC6pJ5ZEh1yWkhkbcFeSjxgx3L2m1cb1C7bceyxA+CNjT/Ifff+/kDk2u/w/33/IeCMOSaWZ4glosqT3DNnNZQ7Cs58/3Ce5HL78iZH/vKVIaYlqzfdLu8Vi7dnvUbEza5Idt36tquZFldl6N5Z/POLof0XLK61mZCmJSWjVF9tEjUluu74IUXvgttuVIHE7YxSkaYhJZam7yiM9Pv82JYfl9nptxZaxMJE4YSPty+vF0+Y2up9d3wwijfjZbabqm/3bZ9ecKHsiGmRflnn1MW4pjHf9oLufyn2z3y1D6n8g8TZhxyzipLNPnAUpsOiuWimg52psrTZYnOWYNDTMuWBWa0tJb4rgq1UvmutpaYEbZlwU3CLJm/ayYjHW5/h7xWLn9Hh1vepDkyf7dE7MtT5LR4e7yYpHrkhOUpEfssBLq2pPhAqoSWKUkk7EDqkmK6RrCEzqDjhNDWNE+XSMvkJRDWlZTmCW0l0PHQGRZY5t1L83kT0Y3l2SItk5JAWHl2dCOBm+fPu3fo5/3v61RMCO9Jx2EEYYhb0rmNQMX/vm7gqOEJLcXTGw3CAuRNeyaPWwjR8PRqKQ1PDA/dpv+on9Shox52WFnx0KY8onHayrJzm87i5h9xGw/tfkev0jGsQizqezUKjk12hBMKJ4kbCqGPVNXudyyrShovGw5CgxsRICxF6aRmSjlBnHRzg7Gx8fKqEubI2rahQYdR1YgDIRQO7JvQyD52hoIQx0mxa0ODtW2Iozn1le2iIRdzwWewedyZzewidueOGqlsn1MvcnQpuVwLGG3/IR1hIKxCjelIDZ8ldqWz25jWAsnldEnK0Zxro19TGVb2ffIZEsIO89EIEDvKMPrzmBOQcKQ+rroye6NgRRxqR4U8EAkz0CL6uSGOm6KQCdWjvjRiSP1BPalCRS5iQYiEIvxuBMJEWgzSoHADcVMuN7IuqqTeyUPq22qFimFtxDyBBJEwNyt6TM88blFHao/6tWWhuuOM4SAK4EI4QmFHA+SEyWlp4EQoJ13cYGzMu7yszEIBOm2rVmHUNqwAIQabISNMRstmdhNWcFLsSm+0tjJH1MdRxO5Nx0WDMhCtgD6OKgZeljJqJKc9po8juskR9XN0Y1lZ3mWjLR9JCO1jRDMd0fpYC2VnvjBSEFg7wBENc0R9HFlb0xvF1+TBEpF68d+DHR6IOWVv2BECtxo46hOFUBd/APU57WIoEwJhIi2CdpyZX0m93BZicktMj1AS9dClteUFAUNUIEygRZCtik5zSxI9MubTBH1GOiHsiLJ3OCoSZkILa9PxiN0EbvhsAo8tdAf9Seepd36lGWHmtNANTv5Jd0z4QYyeo/UEJqxKRpg5LZx6btLPsOaEmdMyxYdlc8LMaJnikDlhclqmPiQnTEpLUIZEwkRagjYkEibQErwhkTAKCLQEbUgkzJQWc/0PstHHcfEdQ+UAAAAASUVORK5CYII=);background-size:26px 26px}.leaflet-touch .leaflet-control-layers-toggle{width:44px;height:44px}.leaflet-control-layers .leaflet-control-layers-list,.leaflet-control-layers-expanded .leaflet-control-layers-toggle{display:none}.leaflet-control-layers-expanded .leaflet-control-layers-list{display:block;position:relative}.leaflet-control-layers-expanded{color:#333;background:#fff;padding:6px 10px 6px 6px}.leaflet-control-layers-scrollbar{padding-right:5px;overflow:hidden scroll}.leaflet-control-layers-selector{margin-top:2px;position:relative;top:1px}.leaflet-control-layers label{font-size:1.08333em;display:block}.leaflet-control-layers-separator{border-top:1px solid #ddd;height:0;margin:5px -10px 5px -6px}.leaflet-default-icon-path{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAApCAYAAADAk4LOAAAFgUlEQVR4Aa1XA5BjWRTN2oW17d3YaZtr2962HUzbDNpjszW24mRt28p47v7zq/bXZtrp/lWnXr337j3nPCe85NcypgSFdugCpW5YoDAMRaIMqRi6aKq5E3YqDQO3qAwjVWrD8Ncq/RBpykd8oZUb/kaJutow8r1aP9II0WmLKLIsJyv1w/kqw9Ch2MYdB++12Onxee/QMwvf4/Dk/Lfp/i4nxTXtOoQ4pW5Aj7wpici1A9erdAN2OH64x8OSP9j3Ft3b7aWkTg/Fm91siTra0f9on5sQr9INejH6CUUUpavjFNq1B+Oadhxmnfa8RfEmN8VNAsQhPqF55xHkMzz3jSmChWU6f7/XZKNH+9+hBLOHYozuKQPxyMPUKkrX/K0uWnfFaJGS1QPRtZsOPtr3NsW0uyh6NNCOkU3Yz+bXbT3I8G3xE5EXLXtCXbbqwCO9zPQYPRTZ5vIDXD7U+w7rFDEoUUf7ibHIR4y6bLVPXrz8JVZEql13trxwue/uDivd3fkWRbS6/IA2bID4uk0UpF1N8qLlbBlXs4Ee7HLTfV1j54APvODnSfOWBqtKVvjgLKzF5YdEk5ewRkGlK0i33Eofffc7HT56jD7/6U+qH3Cx7SBLNntH5YIPvODnyfIXZYRVDPqgHtLs5ABHD3YzLuespb7t79FY34DjMwrVrcTuwlT55YMPvOBnRrJ4VXTdNnYug5ucHLBjEpt30701A3Ts+HEa73u6dT3FNWwflY86eMHPk+Yu+i6pzUpRrW7SNDg5JHR4KapmM5Wv2E8Tfcb1HoqqHMHU+uWDD7zg54mz5/2BSnizi9T1Dg4QQXLToGNCkb6tb1NU+QAlGr1++eADrzhn/u8Q2YZhQVlZ5+CAOtqfbhmaUCS1ezNFVm2imDbPmPng5wmz+gwh+oHDce0eUtQ6OGDIyR0uUhUsoO3vfDmmgOezH0mZN59x7MBi++WDL1g/eEiU3avlidO671bkLfwbw5XV2P8Pzo0ydy4t2/0eu33xYSOMOD8hTf4CrBtGMSoXfPLchX+J0ruSePw3LZeK0juPJbYzrhkH0io7B3k164hiGvawhOKMLkrQLyVpZg8rHFW7E2uHOL888IBPlNZ1FPzstSJM694fWr6RwpvcJK60+0HCILTBzZLFNdtAzJaohze60T8qBzyh5ZuOg5e7uwQppofEmf2++DYvmySqGBuKaicF1blQjhuHdvCIMvp8whTTfZzI7RldpwtSzL+F1+wkdZ2TBOW2gIF88PBTzD/gpeREAMEbxnJcaJHNHrpzji0gQCS6hdkEeYt9DF/2qPcEC8RM28Hwmr3sdNyht00byAut2k3gufWNtgtOEOFGUwcXWNDbdNbpgBGxEvKkOQsxivJx33iow0Vw5S6SVTrpVq11ysA2Rp7gTfPfktc6zhtXBBC+adRLshf6sG2RfHPZ5EAc4sVZ83yCN00Fk/4kggu40ZTvIEm5g24qtU4KjBrx/BTTH8ifVASAG7gKrnWxJDcU7x8X6Ecczhm3o6YicvsLXWfh3Ch1W0k8x0nXF+0fFxgt4phz8QvypiwCCFKMqXCnqXExjq10beH+UUA7+nG6mdG/Pu0f3LgFcGrl2s0kNNjpmoJ9o4B29CMO8dMT4Q5ox8uitF6fqsrJOr8qnwNbRzv6hSnG5wP+64C7h9lp30hKNtKdWjtdkbuPA19nJ7Tz3zR/ibgARbhb4AlhavcBebmTHcFl2fvYEnW0ox9xMxKBS8btJ+KiEbq9zA4RthQXDhPa0T9TEe69gWupwc6uBUphquXgf+/FrIjweHQS4/pduMe5ERUMHUd9xv8ZR98CxkS4F2n3EUrUZ10EYNw7BWm9x1GiPssi3GgiGRDKWRYZfXlON+dfNbM+GgIwYdwAAAAASUVORK5CYII=)}.leaflet-container .leaflet-control-attribution{background:#fffc;margin:0}.leaflet-control-attribution,.leaflet-control-scale-line{color:#333;padding:0 5px;line-height:1.4}.leaflet-control-attribution a{text-decoration:none}.leaflet-control-attribution a:hover,.leaflet-control-attribution a:focus{text-decoration:underline}.leaflet-attribution-flag{width:1em;height:.6669em;vertical-align:baseline!important;display:inline!important}.leaflet-left .leaflet-control-scale{margin-left:5px}.leaflet-bottom .leaflet-control-scale{margin-bottom:5px}.leaflet-control-scale-line{white-space:nowrap;box-sizing:border-box;text-shadow:1px 1px #fff;background:#fffc;border:2px solid #777;border-top:none;padding:2px 5px 1px;line-height:1.1}.leaflet-control-scale-line:not(:first-child){border-top:2px solid #777;border-bottom:none;margin-top:-2px}.leaflet-control-scale-line:not(:first-child):not(:last-child){border-bottom:2px solid #777}.leaflet-touch .leaflet-control-attribution,.leaflet-touch .leaflet-control-layers,.leaflet-touch .leaflet-bar{box-shadow:none}.leaflet-touch .leaflet-control-layers,.leaflet-touch .leaflet-bar{background-clip:padding-box;border:2px solid #0003}.leaflet-popup{text-align:center;margin-bottom:20px;position:absolute}.leaflet-popup-content-wrapper{text-align:left;border-radius:12px;padding:1px}.leaflet-popup-content{min-height:1px;margin:13px 24px 13px 20px;font-size:1.08333em;line-height:1.3}.leaflet-popup-content p{margin:1.3em 0}.leaflet-popup-tip-container{pointer-events:none;width:40px;height:20px;margin-top:-1px;margin-left:-20px;position:absolute;left:50%;overflow:hidden}.leaflet-popup-tip{pointer-events:auto;width:17px;height:17px;margin:-10px auto 0;padding:1px;transform:rotate(45deg)}.leaflet-popup-content-wrapper,.leaflet-popup-tip{color:#333;background:#fff;box-shadow:0 3px 14px #0006}.leaflet-container a.leaflet-popup-close-button{text-align:center;color:#757575;background:0 0;border:none;width:24px;height:24px;font:16px/24px Tahoma,Verdana,sans-serif;text-decoration:none;position:absolute;top:0;right:0}.leaflet-container a.leaflet-popup-close-button:hover,.leaflet-container a.leaflet-popup-close-button:focus{color:#585858}.leaflet-popup-scrolled{overflow:auto}.leaflet-oldie .leaflet-popup-content-wrapper{-ms-zoom:1}.leaflet-oldie .leaflet-popup-tip{-ms-filter:"progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";width:24px;filter:progid:DXImageTransform.Microsoft.Matrix(M11=.707107, M12=.707107, M21=-.707107, M22=.707107);margin:0 auto}.leaflet-oldie .leaflet-control-zoom,.leaflet-oldie .leaflet-control-layers,.leaflet-oldie .leaflet-popup-content-wrapper,.leaflet-oldie .leaflet-popup-tip{border:1px solid #999}.leaflet-div-icon{background:#fff;border:1px solid #666}.leaflet-tooltip{color:#222;white-space:nowrap;-webkit-user-select:none;user-select:none;pointer-events:none;background-color:#fff;border:1px solid #fff;border-radius:3px;padding:6px;position:absolute;box-shadow:0 1px 3px #0006}.leaflet-tooltip.leaflet-interactive{cursor:pointer;pointer-events:auto}.leaflet-tooltip-top:before,.leaflet-tooltip-bottom:before,.leaflet-tooltip-left:before,.leaflet-tooltip-right:before{pointer-events:none;content:"";background:0 0;border:6px solid #0000;position:absolute}.leaflet-tooltip-bottom{margin-top:6px}.leaflet-tooltip-top{margin-top:-6px}.leaflet-tooltip-bottom:before,.leaflet-tooltip-top:before{margin-left:-6px;left:50%}.leaflet-tooltip-top:before{border-top-color:#fff;margin-bottom:-12px;bottom:0}.leaflet-tooltip-bottom:before{border-bottom-color:#fff;margin-top:-12px;margin-left:-6px;top:0}.leaflet-tooltip-left{margin-left:-6px}.leaflet-tooltip-right{margin-left:6px}.leaflet-tooltip-left:before,.leaflet-tooltip-right:before{margin-top:-6px;top:50%}.leaflet-tooltip-left:before{border-left-color:#fff;margin-right:-12px;right:0}.leaflet-tooltip-right:before{border-right-color:#fff;margin-left:-12px;left:0}@media print{.leaflet-control{-webkit-print-color-adjust:exact;print-color-adjust:exact}}

frontend/dist/assets/index-xtYPhhTl.css

@@ -1 +0,0 @@
-@import "https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=Syne:wght@400;500;600;700&display=swap";:root{--bg:#0a0c10;--bg2:#111318;--bg3:#181c24;--bg4:#1e232d;--border:#ffffff14;--border2:#ffffff21;--text:#e8eaf0;--text2:#8b90a0;--text3:#555b6e;--green:#22d37a;--green2:#0d6e3a;--green3:#052a17;--red:#f04040;--red2:#7a1a1a;--red3:#2d0808;--blue:#4a9eff;--blue2:#1a4a80;--blue3:#081830;--amber:#f0a020;--amber2:#7a4e08;--amber3:#2d1c02;--accent:#4a9eff;--sidebar-width:240px;--sidebar-collapsed:56px;--topbar-height:56px;--panel-gap:16px;--radius:10px;--radius-sm:6px;--fs-p:clamp(16px, 1.15vw, 18px);--fs-h1:clamp(28px, 2.8vw, 36px);--fs-h2:clamp(24px, 2.4vw, 30px);--fs-h3:clamp(20px, 1.9vw, 24px);--fs-h4:clamp(18px, 1.6vw, 20px);--fs-h5:clamp(16px, 1.3vw, 18px);--fs-h6:clamp(14px, 1.1vw, 16px)}*{box-sizing:border-box;margin:0;padding:0}html,body,#app{width:100%;height:100%;overflow:hidden}body{background:var(--bg);color:var(--text);-webkit-font-smoothing:antialiased;font-family:Syne,sans-serif;font-size:16px;line-height:1.5}p{font-size:var(--fs-p);line-height:1.55}h1{font-size:var(--fs-h1);font-weight:700;line-height:1.15}h2{font-size:var(--fs-h2);font-weight:700;line-height:1.2}h3{font-size:var(--fs-h3);font-weight:600;line-height:1.25}h4{font-size:var(--fs-h4);font-weight:600;line-height:1.3}h5{font-size:var(--fs-h5);font-weight:500;line-height:1.35}h6{font-size:var(--fs-h6);font-weight:500;line-height:1.4}.layout{grid-template-areas:"topbar topbar""sidebar main";grid-template-columns:var(--sidebar-width) 1fr;grid-template-rows:var(--topbar-height) 1fr;width:100vw;height:100vh;transition:grid-template-columns .25s;display:grid}.layout.collapsed{grid-template-columns:var(--sidebar-collapsed) 1fr}.sidebar{background:var(--bg2);border-right:1px solid var(--border);flex-direction:column;grid-area:sidebar;transition:width .25s;display:flex;position:relative;overflow:hidden}.sidebar-toggle{background:var(--bg3);border:1px solid var(--border2);width:24px;height:24px;color:var(--text2);cursor:pointer;z-index:10;border-radius:50%;justify-content:center;align-items:center;font-size:14px;transition:transform .2s;display:flex;position:absolute;top:12px;right:-10px}.layout.collapsed .sidebar-toggle{right:-10px;transform:rotate(180deg)}.topbar-logo{align-items:center;gap:10px;display:flex;position:absolute;top:0;bottom:0;left:16px}.topbar-logo .logo-dot{background:var(--blue);border-radius:50%;flex-shrink:0;width:10px;height:10px;animation:2s ease-in-out infinite pulse}.topbar-logo .logo-text{color:var(--text);letter-spacing:-.3px;white-space:nowrap;font-size:18px;font-weight:700}.sidebar-nav{flex-direction:column;flex:1;gap:4px;padding:14px 8px;display:flex;overflow-y:auto}.nav-item{border-radius:var(--radius-sm);cursor:pointer;color:var(--text2);white-space:nowrap;align-items:center;gap:14px;padding:14px;font-size:16px;font-weight:500;transition:background .15s,color .15s;display:flex;overflow:hidden}.nav-item:hover{background:var(--bg3);color:var(--text)}.nav-item.active{background:var(--blue3);color:var(--blue);border:.5px solid var(--blue2)}.nav-icon{text-align:center;flex-shrink:0;width:20px;font-size:16px}.nav-label{opacity:1;transition:opacity .15s}.layout.collapsed .nav-label{opacity:0;width:0}.sidebar-footer{border-top:1px solid var(--border);color:var(--text3);text-align:center;white-space:nowrap;padding:14px;font-family:DM Mono,monospace;font-size:14px;overflow:hidden}.layout.collapsed .sidebar-footer{opacity:0}.topbar{background:var(--bg2);border-bottom:1px solid var(--border);padding:0 16px;padding-left:calc(var(--sidebar-width) + var(--panel-gap));grid-area:topbar;align-items:center;gap:16px;transition:padding-left .25s;display:flex;position:relative;overflow:hidden}.layout.collapsed .topbar{padding-left:calc(var(--sidebar-collapsed) + var(--panel-gap))}.live-badge{background:var(--green3);color:var(--green);border:.5px solid var(--green2);border-radius:4px;flex-shrink:0;align-items:center;gap:4px;padding:6px 12px;font-family:DM Mono,monospace;font-size:14px;display:flex}.live-dot{background:var(--green);border-radius:50%;width:8px;height:8px;animation:1.5s ease-in-out infinite pulse}.topbar-stats{flex:1;align-items:center;gap:20px;display:flex;overflow:hidden}.stat{flex-shrink:0;align-items:center;gap:14px;display:flex}.stat-label{color:var(--text3);text-transform:uppercase;letter-spacing:.06em;font-family:DM Mono,monospace;font-size:14px}.stat-val{color:var(--text);font-family:DM Mono,monospace;font-size:16px;font-weight:600}.stat-delta{font-family:DM Mono,monospace;font-size:14px}.stat-delta.up{color:var(--green)}.stat-delta.dn{color:var(--red)}.stat-delta.neutral{color:var(--text3)}.topbar-actions{flex-shrink:0;align-items:center;gap:16px;margin-left:auto;display:flex}.btn-ghost{color:var(--blue);border:.5px solid var(--blue2);background:var(--blue3);border-radius:var(--radius-sm);cursor:pointer;padding:8px 16px;font-family:Syne,sans-serif;font-size:15px;font-weight:500;transition:opacity .15s}.btn-ghost:hover{opacity:.85}.icon-btn{background:var(--bg3);border:.5px solid var(--border2);width:32px;height:32px;color:var(--text2);cursor:pointer;border-radius:50%;justify-content:center;align-items:center;font-size:16px;transition:color .15s,border-color .15s;display:flex}.icon-btn:hover{color:var(--text);border-color:var(--border2)}.main{padding:var(--panel-gap);background:var(--bg);grid-area:main;overflow:auto}.view{display:none}.view.active{height:100%;display:block}.dashboard-grid{gap:var(--panel-gap);grid-template-rows:1fr minmax(280px,40%);grid-template-columns:1fr 280px;height:100%;min-height:0;display:grid}.panel{background:var(--bg2);border:.5px solid var(--border);border-radius:var(--radius);flex-direction:column;min-height:0;display:flex;overflow:hidden}.panel-header{border-bottom:.5px solid var(--border);cursor:pointer;-webkit-user-select:none;user-select:none;justify-content:space-between;align-items:center;padding:14px;transition:background .15s;display:flex}.panel-header:hover{background:#ffffff05}.panel-title{color:var(--text3);text-transform:uppercase;letter-spacing:.08em;align-items:center;gap:14px;font-family:DM Mono,monospace;font-size:14px;display:flex}.panel-toggle{color:var(--text3);font-size:14px;transition:transform .2s}.panel.collapsed .panel-toggle{transform:rotate(-90deg)}.panel-body{flex:1;min-height:0;padding:12px;overflow:auto}.panel.collapsed .panel-body{display:none}.panel-subtitle{color:var(--text3);font-size:14px}.positions-separator{border-top:.5px solid var(--border);margin-top:10px;padding-top:10px}.panel-title.mb-sm{margin-bottom:8px}.panel.full-height{height:100%}.hidden{display:none}.map-panel{grid-area:1/1/2/2}#map-container{background:var(--bg3);border-radius:var(--radius-sm);width:100%;height:100%;min-height:300px;overflow:hidden}.signals-panel{grid-area:1/2/3/3}.signals-list{flex-direction:column;gap:16px;display:flex}.market-card{background:var(--bg3);border:.5px solid var(--border);border-radius:var(--radius-sm);cursor:pointer;padding:14px;transition:border-color .15s,background .15s}.market-card:hover{border-color:var(--border2)}.market-card.active{border-color:var(--blue2);background:var(--blue3)}.market-cat{color:var(--text3);text-transform:uppercase;letter-spacing:.06em;margin-bottom:4px;font-family:DM Mono,monospace;font-size:14px}.market-q{color:var(--text);margin-bottom:8px;font-size:15px;font-weight:500;line-height:1.4}.market-footer{justify-content:space-between;align-items:center;gap:16px;display:flex}.prob-bar-wrap{flex:1;min-width:0}.prob-bar-bg{background:var(--bg4);border-radius:2px;height:5px;overflow:hidden}.prob-bar-fill{height:100%;width:var(--prob-width,0%);border-radius:2px;transition:width .8s}.prob-val{flex-shrink:0;font-family:DM Mono,monospace;font-size:15px;font-weight:600}.signal-badge{letter-spacing:.04em;border-radius:4px;flex-shrink:0;padding:2px 6px;font-family:DM Mono,monospace;font-size:14px;font-weight:600}.sig-bull{background:var(--green3);color:var(--green);border:.5px solid var(--green2)}.sig-bear{background:var(--red3);color:var(--red);border:.5px solid var(--red2)}.sig-neut{background:var(--bg4);color:var(--text2);border:.5px solid var(--border2)}.detail-panel{grid-area:2/1/3/2;max-height:100%;overflow:hidden}.detail-panel .panel-body{overflow-y:auto}.detail-header{justify-content:space-between;align-items:flex-start;gap:16px;margin-bottom:12px;display:flex}.detail-tag{color:var(--blue);text-transform:uppercase;letter-spacing:.08em;margin-bottom:4px;font-family:DM Mono,monospace;font-size:14px}.detail-q{color:var(--text);font-size:16px;font-weight:600;line-height:1.5}.detail-meta{color:var(--text3);margin-top:2px;font-family:DM Mono,monospace;font-size:14px}.detail-metrics{flex-shrink:0;align-items:center;gap:16px;display:flex}.metric{text-align:right}.metric-label{color:var(--text3);margin-bottom:2px;font-family:DM Mono,monospace;font-size:14px}.metric-value{font-family:DM Mono,monospace;font-size:14px;font-weight:700}.metric-sep{background:var(--border);width:1px;height:40px}.outcomes-row{gap:16px;margin-bottom:12px;display:flex}.outcome-card{background:var(--bg3);border:.5px solid var(--border);border-radius:var(--radius-sm);text-align:center;flex:1;padding:14px}.outcome-name{color:var(--text2);margin-bottom:4px;font-family:DM Mono,monospace;font-size:14px}.outcome-price{color:var(--text);font-family:DM Mono,monospace;font-size:20px;font-weight:700}.outcome-delta{margin-top:2px;font-family:DM Mono,monospace;font-size:14px}.outcome-card.yes .outcome-price{color:var(--green)}.outcome-card.no .outcome-price{color:var(--red)}.chart-container{background:var(--bg3);border:.5px solid var(--border);border-radius:var(--radius-sm);flex:2;height:160px;min-height:120px;max-height:160px;padding:14px;overflow:hidden}.chart-container canvas{max-height:130px}.chart-label{color:var(--text3);margin-bottom:6px;font-family:DM Mono,monospace;font-size:14px}.ai-box{background:var(--bg3);border:.5px solid var(--blue2);border-radius:var(--radius-sm);align-items:flex-start;gap:14px;margin-bottom:10px;padding:14px;display:flex}.ai-icon{background:var(--blue3);border-radius:6px;flex-shrink:0;justify-content:center;align-items:center;width:32px;height:32px;font-size:14px;display:flex}.ai-label{color:var(--blue);text-transform:uppercase;letter-spacing:.06em;margin-bottom:3px;font-family:DM Mono,monospace;font-size:14px}.ai-text{color:var(--text2);font-size:15px;line-height:1.5}.sim-row{flex-wrap:wrap;align-items:center;gap:16px;display:flex}.sim-label{color:var(--text3);font-family:DM Mono,monospace;font-size:15px}.sim-input{background:var(--bg3);border:.5px solid var(--border2);border-radius:var(--radius-sm);color:var(--text);outline:none;width:100px;padding:8px 14px;font-family:DM Mono,monospace;font-size:16px}.sim-input:focus{border-color:var(--blue2)}.sim-btn-yes{background:var(--green3);border:.5px solid var(--green2);color:var(--green);border-radius:var(--radius-sm);cursor:pointer;padding:8px 16px;font-family:DM Mono,monospace;font-size:15px;font-weight:600;transition:opacity .15s}.sim-btn-no{background:var(--red3);border:.5px solid var(--red2);color:var(--red);border-radius:var(--radius-sm);cursor:pointer;padding:8px 16px;font-family:DM Mono,monospace;font-size:15px;font-weight:600;transition:opacity .15s}.sim-btn-yes:hover,.sim-btn-no:hover{opacity:.85}.sim-disclaimer{color:var(--text3);font-family:DM Mono,monospace;font-size:14px}.legend{align-items:center;gap:16px;display:flex}.legend-item{color:var(--text3);align-items:center;gap:5px;font-family:DM Mono,monospace;font-size:14px;display:flex}.legend-dot{border-radius:50%;width:10px;height:10px}.legend-dot.green{background:var(--green)}.legend-dot.red{background:var(--red)}.legend-dot.gray{background:var(--text3)}.legend.end{margin-left:auto}.table-wrap{border:.5px solid var(--border);border-radius:var(--radius-sm);background:var(--bg3);overflow:auto}table{border-collapse:collapse;width:100%;font-size:16px}th,td{text-align:left;border-bottom:.5px solid var(--border);padding:14px}th{color:var(--text3);text-transform:uppercase;letter-spacing:.06em;background:var(--bg4);font-family:DM Mono,monospace;font-size:14px;font-weight:500;position:sticky;top:0}tr:hover td{background:#ffffff05}td{color:var(--text)}.td-mono{font-family:DM Mono,monospace}.td-green{color:var(--green)}.td-red{color:var(--red)}.td-blue{color:var(--blue)}.empty-state{text-align:center;color:var(--text3);padding:40px;font-size:16px}#app .leaflet-container{background:var(--bg3);font-family:DM Mono,monospace}#app .leaflet-popup-content-wrapper{background:var(--bg2);color:var(--text);border:.5px solid var(--border);border-radius:var(--radius-sm)}#app .leaflet-popup-tip{background:var(--bg2)}.sparkline{align-items:flex-end;gap:2px;height:32px;margin-top:6px;display:flex}.spark-bar{background:var(--blue2);border-radius:1px;width:3px;transition:height .3s}@keyframes pulse{0%,to{opacity:1}50%{opacity:.4}}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:var(--bg4);border-radius:3px}::-webkit-scrollbar-thumb:hover{background:var(--text3)}.flex-between{justify-content:space-between;align-items:center;display:flex}.flex-start{justify-content:space-between;align-items:flex-start;display:flex}.flex-row{align-items:center;display:flex}.flex-wrap{flex-wrap:wrap}.gap-6{gap:14px}.gap-8{gap:16px}.text-green{color:var(--green)}.text-red{color:var(--red)}.text-blue{color:var(--blue)}.text-amber{color:var(--amber)}.text-neutral{color:var(--text3)}.bg-green{background:var(--green)}.bg-red{background:var(--red)}.bg-amber{background:var(--amber)}.flex-1{flex:1}.font-mono{font-family:DM Mono,monospace}.text-xs,.text-sm{font-size:14px}.text-base{font-size:15px}.text-lg{font-size:16px}.text-xl{font-size:18px}.font-semibold{font-weight:600}.font-bold{font-weight:700}.mb-4{margin-bottom:4px}.mb-6{margin-bottom:6px}.mb-8{margin-bottom:8px}.mt-4{margin-top:4px}.mt-6{margin-top:6px}.ml-auto{margin-left:auto}.divider{background:var(--border);height:1px;margin:8px 0}.empty-state-sm{text-align:center;color:var(--text3);padding:16px;font-size:16px}.map-popup{color:var(--text);max-width:200px;font-family:Syne,sans-serif;font-size:15px}.map-popup-cat{color:var(--text3);text-transform:uppercase;margin-bottom:4px;font-family:DM Mono,monospace;font-size:14px}.map-popup-q{margin-bottom:4px;font-weight:600;line-height:1.3}.map-popup-prices{gap:16px;font-family:DM Mono,monospace;font-size:15px;display:flex}.map-label-text{color:var(--text2);text-shadow:0 1px 2px #000;font-family:DM Mono,monospace;font-size:14px}@media (width<=1024px){.dashboard-grid{grid-template-rows:auto auto auto;grid-template-columns:1fr}.signals-panel{grid-area:auto;max-height:400px}.map-panel{grid-area:auto;min-height:300px}.detail-panel{grid-area:auto}}@media (width<=640px){.layout{grid-template-columns:0 1fr}.sidebar,.topbar-stats{display:none}.outcomes-row{flex-direction:column}}.leaflet-pane,.leaflet-tile,.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-tile-container,.leaflet-pane>svg,.leaflet-pane>canvas,.leaflet-zoom-box,.leaflet-image-layer,.leaflet-layer{position:absolute;top:0;left:0}.leaflet-container{overflow:hidden}.leaflet-tile,.leaflet-marker-icon,.leaflet-marker-shadow{-webkit-user-select:none;user-select:none;-webkit-user-drag:none}.leaflet-tile::selection{background:0 0}.leaflet-safari .leaflet-tile{image-rendering:-webkit-optimize-contrast}.leaflet-safari .leaflet-tile-container{-webkit-transform-origin:0 0;width:1600px;height:1600px}.leaflet-marker-icon,.leaflet-marker-shadow{display:block}.leaflet-container .leaflet-overlay-pane svg{max-width:none!important;max-height:none!important}.leaflet-container .leaflet-marker-pane img,.leaflet-container .leaflet-shadow-pane img,.leaflet-container .leaflet-tile-pane img,.leaflet-container img.leaflet-image-layer,.leaflet-container .leaflet-tile{width:auto;padding:0;max-width:none!important;max-height:none!important}.leaflet-container img.leaflet-tile{mix-blend-mode:plus-lighter}.leaflet-container.leaflet-touch-zoom{-ms-touch-action:pan-x pan-y;touch-action:pan-x pan-y}.leaflet-container.leaflet-touch-drag{-ms-touch-action:pinch-zoom;touch-action:none;touch-action:pinch-zoom}.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom{-ms-touch-action:none;touch-action:none}.leaflet-container{-webkit-tap-highlight-color:transparent}.leaflet-container a{-webkit-tap-highlight-color:#33b5e566}.leaflet-tile{filter:inherit;visibility:hidden}.leaflet-tile-loaded{visibility:inherit}.leaflet-zoom-box{box-sizing:border-box;z-index:800;width:0;height:0}.leaflet-overlay-pane svg{-moz-user-select:none}.leaflet-pane{z-index:400}.leaflet-tile-pane{z-index:200}.leaflet-overlay-pane{z-index:400}.leaflet-shadow-pane{z-index:500}.leaflet-marker-pane{z-index:600}.leaflet-tooltip-pane{z-index:650}.leaflet-popup-pane{z-index:700}.leaflet-map-pane canvas{z-index:100}.leaflet-map-pane svg{z-index:200}.leaflet-vml-shape{width:1px;height:1px}.lvml{behavior:url(#default#VML);display:inline-block;position:absolute}.leaflet-control{z-index:800;pointer-events:visiblePainted;pointer-events:auto;position:relative}.leaflet-top,.leaflet-bottom{z-index:1000;pointer-events:none;position:absolute}.leaflet-top{top:0}.leaflet-right{right:0}.leaflet-bottom{bottom:0}.leaflet-left{left:0}.leaflet-control{float:left;clear:both}.leaflet-right .leaflet-control{float:right}.leaflet-top .leaflet-control{margin-top:10px}.leaflet-bottom .leaflet-control{margin-bottom:10px}.leaflet-left .leaflet-control{margin-left:10px}.leaflet-right .leaflet-control{margin-right:10px}.leaflet-fade-anim .leaflet-popup{opacity:0;transition:opacity .2s linear}.leaflet-fade-anim .leaflet-map-pane .leaflet-popup{opacity:1}.leaflet-zoom-animated{transform-origin:0 0}svg.leaflet-zoom-animated{will-change:transform}.leaflet-zoom-anim .leaflet-zoom-animated{-webkit-transition:-webkit-transform .25s cubic-bezier(0,0,.25,1);-moz-transition:-moz-transform .25s cubic-bezier(0,0,.25,1);transition:transform .25s cubic-bezier(0,0,.25,1)}.leaflet-zoom-anim .leaflet-tile,.leaflet-pan-anim .leaflet-tile{transition:none}.leaflet-zoom-anim .leaflet-zoom-hide{visibility:hidden}.leaflet-interactive{cursor:pointer}.leaflet-grab{cursor:-webkit-grab;cursor:-moz-grab;cursor:grab}.leaflet-crosshair,.leaflet-crosshair .leaflet-interactive{cursor:crosshair}.leaflet-popup-pane,.leaflet-control{cursor:auto}.leaflet-dragging .leaflet-grab,.leaflet-dragging .leaflet-grab .leaflet-interactive,.leaflet-dragging .leaflet-marker-draggable{cursor:move;cursor:-webkit-grabbing;cursor:-moz-grabbing;cursor:grabbing}.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-image-layer,.leaflet-pane>svg path,.leaflet-tile-container{pointer-events:none}.leaflet-marker-icon.leaflet-interactive,.leaflet-image-layer.leaflet-interactive,.leaflet-pane>svg path.leaflet-interactive,svg.leaflet-image-layer.leaflet-interactive path{pointer-events:visiblePainted;pointer-events:auto}.leaflet-container{outline-offset:1px;background:#ddd}.leaflet-container a{color:#0078a8}.leaflet-zoom-box{background:#ffffff80;border:2px dotted #38f}.leaflet-container{font-family:Helvetica Neue,Arial,Helvetica,sans-serif;font-size:.75rem;line-height:1.5}.leaflet-bar{border-radius:4px;box-shadow:0 1px 5px #000000a6}.leaflet-bar a{text-align:center;color:#000;background-color:#fff;border-bottom:1px solid #ccc;width:26px;height:26px;line-height:26px;text-decoration:none;display:block}.leaflet-bar a,.leaflet-control-layers-toggle{background-position:50%;background-repeat:no-repeat;display:block}.leaflet-bar a:hover,.leaflet-bar a:focus{background-color:#f4f4f4}.leaflet-bar a:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.leaflet-bar a:last-child{border-bottom:none;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.leaflet-bar a.leaflet-disabled{cursor:default;color:#bbb;background-color:#f4f4f4}.leaflet-touch .leaflet-bar a{width:30px;height:30px;line-height:30px}.leaflet-touch .leaflet-bar a:first-child{border-top-left-radius:2px;border-top-right-radius:2px}.leaflet-touch .leaflet-bar a:last-child{border-bottom-right-radius:2px;border-bottom-left-radius:2px}.leaflet-control-zoom-in,.leaflet-control-zoom-out{text-indent:1px;font:700 18px Lucida Console,Monaco,monospace}.leaflet-touch .leaflet-control-zoom-in,.leaflet-touch .leaflet-control-zoom-out{font-size:22px}.leaflet-control-layers{background:#fff;border-radius:5px;box-shadow:0 1px 5px #0006}.leaflet-control-layers-toggle{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABoAAAAaCAQAAAADQ4RFAAACf0lEQVR4AY1UM3gkARTePdvdoTxXKc+qTl3aU5U6b2Kbkz3Gtq3Zw6ziLGNPzrYx7946Tr6/ee/XeCQ4D3ykPtL5tHno4n0d/h3+xfuWHGLX81cn7r0iTNzjr7LrlxCqPtkbTQEHeqOrTy4Yyt3VCi/IOB0v7rVC7q45Q3Gr5K6jt+3Gl5nCoDD4MtO+j96Wu8atmhGqcNGHObuf8OM/x3AMx38+4Z2sPqzCxRFK2aF2e5Jol56XTLyggAMTL56XOMoS1W4pOyjUcGGQdZxU6qRh7B9Zp+PfpOFlqt0zyDZckPi1ttmIp03jX8gyJ8a/PG2yutpS/Vol7peZIbZcKBAEEheEIAgFbDkz5H6Zrkm2hVWGiXKiF4Ycw0RWKdtC16Q7qe3X4iOMxruonzegJzWaXFrU9utOSsLUmrc0YjeWYjCW4PDMADElpJSSQ0vQvA1Tm6/JlKnqFs1EGyZiFCqnRZTEJJJiKRYzVYzJck2Rm6P4iH+cmSY0YzimYa8l0EtTODFWhcMIMVqdsI2uiTvKmTisIDHJ3od5GILVhBCarCfVRmo4uTjkhrhzkiBV7SsaqS+TzrzM1qpGGUFt28pIySQHR6h7F6KSwGWm97ay+Z+ZqMcEjEWebE7wxCSQwpkhJqoZA5ivCdZDjJepuJ9IQjGGUmuXJdBFUygxVqVsxFsLMbDe8ZbDYVCGKxs+W080max1hFCarCfV+C1KATwcnvE9gRRuMP2prdbWGowm1KB1y+zwMMENkM755cJ2yPDtqhTI6ED1M/82yIDtC/4j4BijjeObflpO9I9MwXTCsSX8jWAFeHr05WoLTJ5G8IQVS/7vwR6ohirYM7f6HzYpogfS3R2OAAAAAElFTkSuQmCC);width:36px;height:36px}.leaflet-retina .leaflet-control-layers-toggle{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADQAAAA0CAQAAABvcdNgAAAEsklEQVR4AWL4TydIhpZK1kpWOlg0w3ZXP6D2soBtG42jeI6ZmQTHzAxiTbSJsYLjO9HhP+WOmcuhciVnmHVQcJnp7DFvScowZorad/+V/fVzMdMT2g9Cv9guXGv/7pYOrXh2U+RRR3dSd9JRx6bIFc/ekqHI29JC6pJ5ZEh1yWkhkbcFeSjxgx3L2m1cb1C7bceyxA+CNjT/Ifff+/kDk2u/w/33/IeCMOSaWZ4glosqT3DNnNZQ7Cs58/3Ce5HL78iZH/vKVIaYlqzfdLu8Vi7dnvUbEza5Idt36tquZFldl6N5Z/POLof0XLK61mZCmJSWjVF9tEjUluu74IUXvgttuVIHE7YxSkaYhJZam7yiM9Pv82JYfl9nptxZaxMJE4YSPty+vF0+Y2up9d3wwijfjZbabqm/3bZ9ecKHsiGmRflnn1MW4pjHf9oLufyn2z3y1D6n8g8TZhxyzipLNPnAUpsOiuWimg52psrTZYnOWYNDTMuWBWa0tJb4rgq1UvmutpaYEbZlwU3CLJm/ayYjHW5/h7xWLn9Hh1vepDkyf7dE7MtT5LR4e7yYpHrkhOUpEfssBLq2pPhAqoSWKUkk7EDqkmK6RrCEzqDjhNDWNE+XSMvkJRDWlZTmCW0l0PHQGRZY5t1L83kT0Y3l2SItk5JAWHl2dCOBm+fPu3fo5/3v61RMCO9Jx2EEYYhb0rmNQMX/vm7gqOEJLcXTGw3CAuRNeyaPWwjR8PRqKQ1PDA/dpv+on9Shox52WFnx0KY8onHayrJzm87i5h9xGw/tfkev0jGsQizqezUKjk12hBMKJ4kbCqGPVNXudyyrShovGw5CgxsRICxF6aRmSjlBnHRzg7Gx8fKqEubI2rahQYdR1YgDIRQO7JvQyD52hoIQx0mxa0ODtW2Iozn1le2iIRdzwWewedyZzewidueOGqlsn1MvcnQpuVwLGG3/IR1hIKxCjelIDZ8ldqWz25jWAsnldEnK0Zxro19TGVb2ffIZEsIO89EIEDvKMPrzmBOQcKQ+rroye6NgRRxqR4U8EAkz0CL6uSGOm6KQCdWjvjRiSP1BPalCRS5iQYiEIvxuBMJEWgzSoHADcVMuN7IuqqTeyUPq22qFimFtxDyBBJEwNyt6TM88blFHao/6tWWhuuOM4SAK4EI4QmFHA+SEyWlp4EQoJ13cYGzMu7yszEIBOm2rVmHUNqwAIQabISNMRstmdhNWcFLsSm+0tjJH1MdRxO5Nx0WDMhCtgD6OKgZeljJqJKc9po8juskR9XN0Y1lZ3mWjLR9JCO1jRDMd0fpYC2VnvjBSEFg7wBENc0R9HFlb0xvF1+TBEpF68d+DHR6IOWVv2BECtxo46hOFUBd/APU57WIoEwJhIi2CdpyZX0m93BZicktMj1AS9dClteUFAUNUIEygRZCtik5zSxI9MubTBH1GOiHsiLJ3OCoSZkILa9PxiN0EbvhsAo8tdAf9Seepd36lGWHmtNANTv5Jd0z4QYyeo/UEJqxKRpg5LZx6btLPsOaEmdMyxYdlc8LMaJnikDlhclqmPiQnTEpLUIZEwkRagjYkEibQErwhkTAKCLQEbUgkzJQWc/0PstHHcfEdQ+UAAAAASUVORK5CYII=);background-size:26px 26px}.leaflet-touch .leaflet-control-layers-toggle{width:44px;height:44px}.leaflet-control-layers .leaflet-control-layers-list,.leaflet-control-layers-expanded .leaflet-control-layers-toggle{display:none}.leaflet-control-layers-expanded .leaflet-control-layers-list{display:block;position:relative}.leaflet-control-layers-expanded{color:#333;background:#fff;padding:6px 10px 6px 6px}.leaflet-control-layers-scrollbar{padding-right:5px;overflow:hidden scroll}.leaflet-control-layers-selector{margin-top:2px;position:relative;top:1px}.leaflet-control-layers label{font-size:1.08333em;display:block}.leaflet-control-layers-separator{border-top:1px solid #ddd;height:0;margin:5px -10px 5px -6px}.leaflet-default-icon-path{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAApCAYAAADAk4LOAAAFgUlEQVR4Aa1XA5BjWRTN2oW17d3YaZtr2962HUzbDNpjszW24mRt28p47v7zq/bXZtrp/lWnXr337j3nPCe85NcypgSFdugCpW5YoDAMRaIMqRi6aKq5E3YqDQO3qAwjVWrD8Ncq/RBpykd8oZUb/kaJutow8r1aP9II0WmLKLIsJyv1w/kqw9Ch2MYdB++12Onxee/QMwvf4/Dk/Lfp/i4nxTXtOoQ4pW5Aj7wpici1A9erdAN2OH64x8OSP9j3Ft3b7aWkTg/Fm91siTra0f9on5sQr9INejH6CUUUpavjFNq1B+Oadhxmnfa8RfEmN8VNAsQhPqF55xHkMzz3jSmChWU6f7/XZKNH+9+hBLOHYozuKQPxyMPUKkrX/K0uWnfFaJGS1QPRtZsOPtr3NsW0uyh6NNCOkU3Yz+bXbT3I8G3xE5EXLXtCXbbqwCO9zPQYPRTZ5vIDXD7U+w7rFDEoUUf7ibHIR4y6bLVPXrz8JVZEql13trxwue/uDivd3fkWRbS6/IA2bID4uk0UpF1N8qLlbBlXs4Ee7HLTfV1j54APvODnSfOWBqtKVvjgLKzF5YdEk5ewRkGlK0i33Eofffc7HT56jD7/6U+qH3Cx7SBLNntH5YIPvODnyfIXZYRVDPqgHtLs5ABHD3YzLuespb7t79FY34DjMwrVrcTuwlT55YMPvOBnRrJ4VXTdNnYug5ucHLBjEpt30701A3Ts+HEa73u6dT3FNWwflY86eMHPk+Yu+i6pzUpRrW7SNDg5JHR4KapmM5Wv2E8Tfcb1HoqqHMHU+uWDD7zg54mz5/2BSnizi9T1Dg4QQXLToGNCkb6tb1NU+QAlGr1++eADrzhn/u8Q2YZhQVlZ5+CAOtqfbhmaUCS1ezNFVm2imDbPmPng5wmz+gwh+oHDce0eUtQ6OGDIyR0uUhUsoO3vfDmmgOezH0mZN59x7MBi++WDL1g/eEiU3avlidO671bkLfwbw5XV2P8Pzo0ydy4t2/0eu33xYSOMOD8hTf4CrBtGMSoXfPLchX+J0ruSePw3LZeK0juPJbYzrhkH0io7B3k164hiGvawhOKMLkrQLyVpZg8rHFW7E2uHOL888IBPlNZ1FPzstSJM694fWr6RwpvcJK60+0HCILTBzZLFNdtAzJaohze60T8qBzyh5ZuOg5e7uwQppofEmf2++DYvmySqGBuKaicF1blQjhuHdvCIMvp8whTTfZzI7RldpwtSzL+F1+wkdZ2TBOW2gIF88PBTzD/gpeREAMEbxnJcaJHNHrpzji0gQCS6hdkEeYt9DF/2qPcEC8RM28Hwmr3sdNyht00byAut2k3gufWNtgtOEOFGUwcXWNDbdNbpgBGxEvKkOQsxivJx33iow0Vw5S6SVTrpVq11ysA2Rp7gTfPfktc6zhtXBBC+adRLshf6sG2RfHPZ5EAc4sVZ83yCN00Fk/4kggu40ZTvIEm5g24qtU4KjBrx/BTTH8ifVASAG7gKrnWxJDcU7x8X6Ecczhm3o6YicvsLXWfh3Ch1W0k8x0nXF+0fFxgt4phz8QvypiwCCFKMqXCnqXExjq10beH+UUA7+nG6mdG/Pu0f3LgFcGrl2s0kNNjpmoJ9o4B29CMO8dMT4Q5ox8uitF6fqsrJOr8qnwNbRzv6hSnG5wP+64C7h9lp30hKNtKdWjtdkbuPA19nJ7Tz3zR/ibgARbhb4AlhavcBebmTHcFl2fvYEnW0ox9xMxKBS8btJ+KiEbq9zA4RthQXDhPa0T9TEe69gWupwc6uBUphquXgf+/FrIjweHQS4/pduMe5ERUMHUd9xv8ZR98CxkS4F2n3EUrUZ10EYNw7BWm9x1GiPssi3GgiGRDKWRYZfXlON+dfNbM+GgIwYdwAAAAASUVORK5CYII=)}.leaflet-container .leaflet-control-attribution{background:#fffc;margin:0}.leaflet-control-attribution,.leaflet-control-scale-line{color:#333;padding:0 5px;line-height:1.4}.leaflet-control-attribution a{text-decoration:none}.leaflet-control-attribution a:hover,.leaflet-control-attribution a:focus{text-decoration:underline}.leaflet-attribution-flag{width:1em;height:.6669em;vertical-align:baseline!important;display:inline!important}.leaflet-left .leaflet-control-scale{margin-left:5px}.leaflet-bottom .leaflet-control-scale{margin-bottom:5px}.leaflet-control-scale-line{white-space:nowrap;box-sizing:border-box;text-shadow:1px 1px #fff;background:#fffc;border:2px solid #777;border-top:none;padding:2px 5px 1px;line-height:1.1}.leaflet-control-scale-line:not(:first-child){border-top:2px solid #777;border-bottom:none;margin-top:-2px}.leaflet-control-scale-line:not(:first-child):not(:last-child){border-bottom:2px solid #777}.leaflet-touch .leaflet-control-attribution,.leaflet-touch .leaflet-control-layers,.leaflet-touch .leaflet-bar{box-shadow:none}.leaflet-touch .leaflet-control-layers,.leaflet-touch .leaflet-bar{background-clip:padding-box;border:2px solid #0003}.leaflet-popup{text-align:center;margin-bottom:20px;position:absolute}.leaflet-popup-content-wrapper{text-align:left;border-radius:12px;padding:1px}.leaflet-popup-content{min-height:1px;margin:13px 24px 13px 20px;font-size:1.08333em;line-height:1.3}.leaflet-popup-content p{margin:1.3em 0}.leaflet-popup-tip-container{pointer-events:none;width:40px;height:20px;margin-top:-1px;margin-left:-20px;position:absolute;left:50%;overflow:hidden}.leaflet-popup-tip{pointer-events:auto;width:17px;height:17px;margin:-10px auto 0;padding:1px;transform:rotate(45deg)}.leaflet-popup-content-wrapper,.leaflet-popup-tip{color:#333;background:#fff;box-shadow:0 3px 14px #0006}.leaflet-container a.leaflet-popup-close-button{text-align:center;color:#757575;background:0 0;border:none;width:24px;height:24px;font:16px/24px Tahoma,Verdana,sans-serif;text-decoration:none;position:absolute;top:0;right:0}.leaflet-container a.leaflet-popup-close-button:hover,.leaflet-container a.leaflet-popup-close-button:focus{color:#585858}.leaflet-popup-scrolled{overflow:auto}.leaflet-oldie .leaflet-popup-content-wrapper{-ms-zoom:1}.leaflet-oldie .leaflet-popup-tip{-ms-filter:"progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";width:24px;filter:progid:DXImageTransform.Microsoft.Matrix(M11=.707107, M12=.707107, M21=-.707107, M22=.707107);margin:0 auto}.leaflet-oldie .leaflet-control-zoom,.leaflet-oldie .leaflet-control-layers,.leaflet-oldie .leaflet-popup-content-wrapper,.leaflet-oldie .leaflet-popup-tip{border:1px solid #999}.leaflet-div-icon{background:#fff;border:1px solid #666}.leaflet-tooltip{color:#222;white-space:nowrap;-webkit-user-select:none;user-select:none;pointer-events:none;background-color:#fff;border:1px solid #fff;border-radius:3px;padding:6px;position:absolute;box-shadow:0 1px 3px #0006}.leaflet-tooltip.leaflet-interactive{cursor:pointer;pointer-events:auto}.leaflet-tooltip-top:before,.leaflet-tooltip-bottom:before,.leaflet-tooltip-left:before,.leaflet-tooltip-right:before{pointer-events:none;content:"";background:0 0;border:6px solid #0000;position:absolute}.leaflet-tooltip-bottom{margin-top:6px}.leaflet-tooltip-top{margin-top:-6px}.leaflet-tooltip-bottom:before,.leaflet-tooltip-top:before{margin-left:-6px;left:50%}.leaflet-tooltip-top:before{border-top-color:#fff;margin-bottom:-12px;bottom:0}.leaflet-tooltip-bottom:before{border-bottom-color:#fff;margin-top:-12px;margin-left:-6px;top:0}.leaflet-tooltip-left{margin-left:-6px}.leaflet-tooltip-right{margin-left:6px}.leaflet-tooltip-left:before,.leaflet-tooltip-right:before{margin-top:-6px;top:50%}.leaflet-tooltip-left:before{border-left-color:#fff;margin-right:-12px;right:0}.leaflet-tooltip-right:before{border-right-color:#fff;margin-left:-12px;left:0}@media print{.leaflet-control{-webkit-print-color-adjust:exact;print-color-adjust:exact}}

frontend/dist/index.html

@@ -5,8 +5,8 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>PolySignal — Dashboard de Inteligencia de Mercados</title>
   <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-  <script type="module" crossorigin src="/assets/index-B7Y-b3uS.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-xtYPhhTl.css">
+  <script type="module" crossorigin src="/assets/index-pjCx9cLl.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-D_WoXxRV.css">
 </head>
 <body>
   <div id="app" class="layout">
@@ -43,39 +43,83 @@
         <div class="logo-dot"></div>
         <span class="logo-text">PolySignal</span>
       </div>
-      <div class="live-badge">
-        <div class="live-dot"></div>
-        EN VIVO
-      </div>
       <div class="topbar-stats">
-        <div class="stat">
-          <span class="stat-label">Mercados</span>
-          <span class="stat-val" id="stat-markets">2.847</span>
-        </div>
-        <div class="stat">
-          <span class="stat-label">Volumen 24h</span>
-          <span class="stat-val" id="stat-volume">€4,2M</span>
-          <span class="stat-delta up" id="stat-volume-delta">+12,4%</span>
-        </div>
-        <div class="stat">
-          <span class="stat-label">Señales IA</span>
-          <span class="stat-val" id="stat-signals">183</span>
-          <span class="stat-delta up" id="stat-signals-delta">alcista</span>
+        <div class="live-badge">
+          <div class="live-dot"></div>
+          EN VIVO
         </div>
-        <div class="stat">
-          <span class="stat-label">Alertas enviadas</span>
-          <span class="stat-val" id="stat-alerts">47</span>
-          <span class="stat-delta neutral">hoy</span>
-        </div>
-        <div class="legend end">
-          <div class="legend-item"><div class="legend-dot green"></div>alcista</div>
-          <div class="legend-item"><div class="legend-dot red"></div>bajista</div>
-          <div class="legend-item"><div class="legend-dot gray"></div>neutral</div>
+        <div class="stats-track">
+          <div class="stat">
+            <span class="stat-label">Mercados</span>
+            <span class="stat-val" id="stat-markets">2.847</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Volumen 24h</span>
+            <span class="stat-val" id="stat-volume">€4,2M</span>
+            <span class="stat-delta up" id="stat-volume-delta">+12,4%</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Señales IA</span>
+            <span class="stat-val" id="stat-signals">183</span>
+            <span class="stat-delta up" id="stat-signals-delta">alcista</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Alertas enviadas</span>
+            <span class="stat-val" id="stat-alerts">47</span>
+            <span class="stat-delta neutral">hoy</span>
+          </div>
+          <div class="legend end">
+            <div class="legend-item"><div class="legend-dot green"></div>alcista</div>
+            <div class="legend-item"><div class="legend-dot red"></div>bajista</div>
+            <div class="legend-item"><div class="legend-dot gray"></div>neutral</div>
+          </div>
+          <!-- Duplicate for infinite scroll -->
+          <div class="stat">
+            <span class="stat-label">Mercados</span>
+            <span class="stat-val" id="stat-markets-dup">2.847</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Volumen 24h</span>
+            <span class="stat-val" id="stat-volume-dup">€4,2M</span>
+            <span class="stat-delta up">+12,4%</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Señales IA</span>
+            <span class="stat-val" id="stat-signals-dup">183</span>
+            <span class="stat-delta up">alcista</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Alertas enviadas</span>
+            <span class="stat-val" id="stat-alerts-dup">47</span>
+            <span class="stat-delta neutral">hoy</span>
+          </div>
+          <div class="legend">
+            <div class="legend-item"><div class="legend-dot green"></div>alcista</div>
+            <div class="legend-item"><div class="legend-dot red"></div>bajista</div>
+            <div class="legend-item"><div class="legend-dot gray"></div>neutral</div>
+          </div>
         </div>
       </div>
+      <div class="topbar-filters desktop-only">
+        <select class="filter-select" id="filter-trend" title="Tendencias">
+          <option value="">🔥 Todos los mercados</option>
+          <option value="hot">🔥 Más activos</option>
+          <option value="bullish-trend">📈 Tendencia alcista</option>
+          <option value="bearish-trend">📉 Tendencia bajista</option>
+          <option value="volatile">⚡ Más volátiles</option>
+          <option value="high-volume">📊 Alto volumen</option>
+        </select>
+        <select class="filter-select" id="filter-category" title="Categoría">
+          <option value="">Todas las categorías</option>
+        </select>
+
+      </div>
       <div class="topbar-actions">
-        <button class="btn-ghost" id="btn-telegram">Alertas Telegram</button>
+        <button class="btn-ghost desktop-only" id="btn-telegram">Alertas Telegram</button>
+        <button class="icon-btn mobile-only" id="btn-telegram-mobile" title="Alertas Telegram">✈</button>
         <button class="icon-btn" id="btn-notif" title="Notificaciones">◉</button>
+        <button class="btn-ghost desktop-only" id="btn-auth">Entrar</button>
+        <button class="icon-btn auth-indicator mobile-only" id="btn-auth-mobile" title="Entrar"></button>
       </div>
     </header>
 
@@ -91,8 +135,12 @@
             <div class="panel-header" data-panel="map">
               <div class="panel-title">
                 <span>◈</span>
-                Mapa global de predicciones
-                <span class="panel-subtitle">· tamaño = volumen · color = señal IA</span>
+                Mapa global
+              </div>
+              <div class="map-legend">
+                <div class="legend-item"><div class="legend-dot green"></div>alcista</div>
+                <div class="legend-item"><div class="legend-dot red"></div>bajista</div>
+                <div class="legend-item"><div class="legend-dot gray"></div>neutral</div>
               </div>
               <span class="panel-toggle">▼</span>
             </div>
@@ -223,5 +271,115 @@
     </main>
   </div>
 
+  <!-- Telegram Alerts Modal -->
+  <div class="modal-overlay hidden" id="telegram-modal">
+    <div class="modal">
+      <div class="modal-header">
+        <div class="modal-title">
+          <span class="modal-title-icon">✈</span>
+          <span>Alertas Telegram</span>
+        </div>
+        <button class="modal-close" id="telegram-modal-close" title="Cerrar">✕</button>
+      </div>
+      <div class="modal-body">
+        <!-- Instructions -->
+        <div class="telegram-instructions">
+          <div class="instruction-step">
+            <span class="step-num">1</span>
+            <div class="step-body">
+              <strong>Crea tu bot</strong>
+              <p>Abre <a href="https://t.me/BotFather" target="_blank" rel="noopener">@BotFather</a> en Telegram, pulsa <em>/newbot</em> y sigue los pasos. Copia el token que te devuelve (parece <code>123456789:ABC...</code>).</p>
+            </div>
+          </div>
+          <div class="instruction-step">
+            <span class="step-num">2</span>
+            <div class="step-body">
+              <strong>Obtén tu Chat ID</strong>
+              <p>Escríbele a <a href="https://t.me/userinfobot" target="_blank" rel="noopener">@userinfobot</a> y te responderá con tu ID. Si quieres enviarlo a un grupo, añade el bot al grupo y usa <a href="https://t.me/getidsbot" target="_blank" rel="noopener">@getidsbot</a>.</p>
+            </div>
+          </div>
+          <div class="instruction-step">
+            <span class="step-num">3</span>
+            <div class="step-body">
+              <strong>Inicia el bot</strong>
+              <p>En Telegram, abre una conversación con tu bot y pulsa <em>/start</em>. Si usas un grupo, envía <em>/start</em> en el grupo también.</p>
+            </div>
+          </div>
+        </div>
+
+        <form class="modal-form active" id="form-telegram">
+          <div class="form-group">
+            <label for="telegram-bot-token">Token del bot</label>
+            <input type="password" id="telegram-bot-token" placeholder="123456789:ABCdefGHIjklMNOpqrsTUVwxyz" />
+          </div>
+          <div class="form-group">
+            <label for="telegram-chat-id">Chat ID</label>
+            <input type="text" id="telegram-chat-id" placeholder="-1001234567890" />
+          </div>
+          <div class="form-group">
+            <div class="toggle-row">
+              <label for="telegram-enabled">Activar alertas</label>
+              <label class="toggle-switch">
+                <input type="checkbox" id="telegram-enabled" />
+                <span class="toggle-slider"></span>
+              </label>
+            </div>
+          </div>
+          <div class="form-status" id="telegram-status"></div>
+          <div class="form-actions">
+            <button type="button" class="modal-submit modal-submit--secondary" id="btn-test-telegram">Probar conexión</button>
+            <button type="submit" class="modal-submit">Guardar configuración</button>
+          </div>
+        </form>
+      </div>
+    </div>
+  </div>
+
+  <!-- Auth Modal -->
+  <div class="modal-overlay hidden" id="auth-modal">
+    <div class="modal">
+      <div class="modal-header">
+        <div class="modal-tabs">
+          <button class="modal-tab active" data-tab="login">Iniciar sesión</button>
+          <button class="modal-tab" data-tab="register">Registrarse</button>
+        </div>
+        <button class="modal-close" id="modal-close" title="Cerrar">✕</button>
+      </div>
+      <div class="modal-body">
+        <!-- Login Form -->
+        <form class="modal-form active" id="form-login">
+          <div class="form-group">
+            <label for="login-email">Correo electrónico</label>
+            <input type="email" id="login-email" placeholder="usuario@ejemplo.com" required />
+          </div>
+          <div class="form-group">
+            <label for="login-password">Contraseña</label>
+            <input type="password" id="login-password" placeholder="••••••••" required />
+          </div>
+          <div class="form-error" id="login-error"></div>
+          <button type="submit" class="modal-submit">Entrar</button>
+        </form>
+
+        <!-- Register Form -->
+        <form class="modal-form" id="form-register">
+          <div class="form-group">
+            <label for="register-email">Correo electrónico</label>
+            <input type="email" id="register-email" placeholder="usuario@ejemplo.com" required />
+          </div>
+          <div class="form-group">
+            <label for="register-password">Contraseña</label>
+            <input type="password" id="register-password" placeholder="Mínimo 8 caracteres" required minlength="8" />
+          </div>
+          <div class="form-group">
+            <label for="register-password-confirm">Confirmar contraseña</label>
+            <input type="password" id="register-password-confirm" placeholder="Repite la contraseña" required />
+          </div>
+          <div class="form-error" id="register-error"></div>
+          <button type="submit" class="modal-submit">Crear cuenta</button>
+        </form>
+      </div>
+    </div>
+  </div>
+
 </body>
 </html>

frontend/index.html

@@ -98,6 +98,20 @@
           </div>
         </div>
       </div>
+      <div class="topbar-filters desktop-only">
+        <select class="filter-select" id="filter-trend" title="Tendencias">
+          <option value="">🔥 Todos los mercados</option>
+          <option value="hot">🔥 Más activos</option>
+          <option value="bullish-trend">📈 Tendencia alcista</option>
+          <option value="bearish-trend">📉 Tendencia bajista</option>
+          <option value="volatile">⚡ Más volátiles</option>
+          <option value="high-volume">📊 Alto volumen</option>
+        </select>
+        <select class="filter-select" id="filter-category" title="Categoría">
+          <option value="">Todas las categorías</option>
+        </select>
+
+      </div>
       <div class="topbar-actions">
         <button class="btn-ghost desktop-only" id="btn-telegram">Alertas Telegram</button>
         <button class="icon-btn mobile-only" id="btn-telegram-mobile" title="Alertas Telegram">✈</button>

frontend/src/api.js

@@ -69,6 +69,10 @@ export function logout() {
   clearToken()
 }
 
+export async function getMe() {
+  return fetchJson(`${BASE}/auth/me`)
+}
+
 /* ─── Core fetch ─── */
 async function fetchJson(url, opts = {}) {
   const headers = { 'Content-Type': 'application/json', ...opts.headers }
@@ -86,6 +90,7 @@ async function fetchJson(url, opts = {}) {
   })
 
   if (!res.ok) {
+    if (res.status === 401) clearToken()
     const text = await res.text().catch(() => '')
     throw new Error(`HTTP ${res.status}: ${text}`)
   }
@@ -110,6 +115,10 @@ export async function getMarket(id) {
   return fetchJson(`${BASE}/markets/${id}`)
 }
 
+export async function getMarketHistory(id, interval = '1w') {
+  return fetchJson(`${BASE}/markets/${id}/history?interval=${interval}`)
+}
+
 /* ─── Signals ─── */
 export async function getSignal(marketId) {
   return fetchJson(`${BASE}/markets/${marketId}/signal`)
@@ -126,6 +135,10 @@ export async function getPositions() {
   return fetchJson(`${BASE}/positions`)
 }
 
+export async function getPositionSuggestion(marketId, bankroll = 1000) {
+  return fetchJson(`${BASE}/positions/suggestion/${marketId}?bankroll=${bankroll}`)
+}
+
 export async function createPosition(data) {
   return fetchJson(`${BASE}/positions`, {
     method: 'POST',

frontend/src/app.js

@@ -30,6 +30,7 @@ import * as api from './api.js'
 import * as charts from './charts.js'
 import * as map from './map.js'
 import * as simulator from './simulator.js'
+import { extractFilterOptions, filterMarkets } from './filters.js'
 
 /* ─── Estado global ─── */
 let state = {
@@ -45,6 +46,8 @@ let state = {
   signalsOffset: 0,
   signalsHasMore: true,
   signalsLoading: false,
+  filters: { category: '', trend: '' },
+  priceHistory: new Map(), // marketId → [{price, timestamp}]
 }
 
 let signalsObserver = null
@@ -109,6 +112,134 @@ function emptyState(text, sm = false) {
   return el('div', sm ? 'empty-state empty-state-sm' : 'empty-state', text)
 }
 
+/* ─── Filters ─── */
+function populateFilters() {
+  const opts = extractFilterOptions(state.markets)
+
+  const catSel = document.getElementById('filter-category')
+  if (!catSel) return
+
+  const currentCat = catSel.value
+  catSel.innerHTML = '<option value="">Todas las categorías</option>' +
+    opts.categories.slice(1).map((c) => `<option value="${c}">${c.charAt(0).toUpperCase() + c.slice(1)}</option>`).join('')
+  catSel.value = opts.categories.includes(currentCat) ? currentCat : ''
+}
+
+function applyFilters() {
+  state.filters.category = document.getElementById('filter-category')?.value || ''
+  state.filters.trend = document.getElementById('filter-trend')?.value || ''
+
+  let filtered = filterMarkets(state.markets, state.filters)
+  if (state.filters.trend) {
+    filtered = filterByTrend(filtered, state.filters.trend)
+  }
+  renderSignalsFiltered(filtered)
+  map.updateMarkers(filtered, state.signals)
+}
+
+function initFilters() {
+  populateFilters()
+  document.getElementById('filter-category')?.addEventListener('change', applyFilters)
+  document.getElementById('filter-trend')?.addEventListener('change', applyFilters)
+}
+
+/* ─── Trend Tracking ─── */
+function recordPrice(marketId, price) {
+  if (!state.priceHistory.has(marketId)) {
+    state.priceHistory.set(marketId, [])
+  }
+  const history = state.priceHistory.get(marketId)
+  history.push({ price, timestamp: Date.now() })
+  // Mantener solo últimos 20 registros (~10 min con sync cada 30s)
+  if (history.length > 20) history.shift()
+}
+
+function getMarketTrend(marketId) {
+  const history = state.priceHistory.get(marketId)
+  if (!history || history.length < 2) return { momentum: 0, volatility: 0, avgVolume: 0 }
+
+  const prices = history.map((h) => h.price)
+  const first = prices[0]
+  const last = prices[prices.length - 1]
+  const momentum = first !== 0 ? ((last - first) / first) * 100 : 0
+
+  // Volatilidad = desviación estándar de cambios porcentuales
+  let volatility = 0
+  if (prices.length >= 3) {
+    const changes = []
+    for (let i = 1; i < prices.length; i++) {
+      if (prices[i - 1] !== 0) {
+        changes.push(((prices[i] - prices[i - 1]) / prices[i - 1]) * 100)
+      }
+    }
+    if (changes.length > 1) {
+      const mean = changes.reduce((a, b) => a + b, 0) / changes.length
+      const variance = changes.reduce((sum, c) => sum + Math.pow(c - mean, 2), 0) / changes.length
+      volatility = Math.sqrt(variance)
+    }
+  }
+
+  return { momentum, volatility }
+}
+
+function filterByTrend(markets, trendType) {
+  if (!trendType) return markets
+
+  // Precalcular trends
+  const withTrend = markets.map((m) => {
+    const trend = getMarketTrend(m.id)
+    const sig = state.signals.find((s) => s.marketId === m.id)
+    return {
+      market: m,
+      momentum: trend.momentum,
+      volatility: trend.volatility,
+      volume: m.volumeEur || 0,
+      signal: sig?.signal || 'neutral',
+      confidence: sig?.confidence || 0.5,
+    }
+  })
+
+  switch (trendType) {
+    case 'hot':
+      // Más activos = mayor volumen + algún movimiento reciente
+      return withTrend
+        .filter((w) => w.volume > 100000 || Math.abs(w.momentum) > 1)
+        .sort((a, b) => b.volume - a.volume)
+        .map((w) => w.market)
+
+    case 'bullish-trend':
+      // Tendencia alcista = momentum positivo + señal bullish
+      return withTrend
+        .filter((w) => w.momentum > 0.5 || w.signal === 'bullish')
+        .sort((a, b) => b.momentum - a.momentum)
+        .map((w) => w.market)
+
+    case 'bearish-trend':
+      // Tendencia bajista = momentum negativo + señal bearish
+      return withTrend
+        .filter((w) => w.momentum < -0.5 || w.signal === 'bearish')
+        .sort((a, b) => a.momentum - b.momentum)
+        .map((w) => w.market)
+
+    case 'volatile':
+      // Más volátiles = mayor desviación estándar de cambios
+      return withTrend
+        .filter((w) => w.volatility > 0.3)
+        .sort((a, b) => b.volatility - a.volatility)
+        .map((w) => w.market)
+
+    case 'high-volume':
+      // Alto volumen
+      return withTrend
+        .filter((w) => w.volume > 500000)
+        .sort((a, b) => b.volume - a.volume)
+        .map((w) => w.market)
+
+    default:
+      return markets
+  }
+}
+
 /* ─── Auth Modal ─── */
 function openAuthModal() {
   document.getElementById('auth-modal')?.classList.remove('hidden')
@@ -290,8 +421,14 @@ async function handleRegister(e) {
 }
 
 async function ensureAuth() {
-  if (api.isAuthenticated()) return true
-  return false
+  if (!api.isAuthenticated()) return false
+  try {
+    await api.getMe()
+    return true
+  } catch (e) {
+    // Token inválido o expirado — ya fue borrado por fetchJson
+    return false
+  }
 }
 
 /* ─── Routing de vistas ─── */
@@ -321,14 +458,27 @@ function togglePanel(panelId) {
 
 /* ─── Signal card factory ─── */
 function makeSignalCard(m) {
-  const sig = state.signals.find((s) => s.marketId === m.id) || { signal: 'neutral', confidence: 0.5 }
-  const cls = signalColorClass(sig.signal)
+  const sig = state.signals.find((s) => s.marketId === m.id) || null
+  const hasSignal = sig != null
+  const cls = signalColorClass(sig?.signal || 'neutral')
 
   const card = el('div', `market-card${state.activeMarketId === m.id ? ' active' : ''}`)
   card.dataset.market = m.id
 
   const cat = el('div', 'market-cat')
-  cat.textContent = `${m.category || 'General'} · ${m.countryCode || 'GL'}`
+  const catLabel = `${m.category || 'General'} · ${m.countryCode || 'GL'}`
+  cat.textContent = catLabel
+
+  // Spread badge si Polymarket reporta uno wide
+  if (m.spread != null && m.spread > 0.05) {
+    const spreadBadge = el('span', 'spread-badge illiquid')
+    spreadBadge.textContent = `· ilíquido ${Math.round(m.spread * 100)}¢`
+    cat.appendChild(spreadBadge)
+  } else if (m.spread != null && m.spread > 0.02) {
+    const spreadBadge = el('span', 'spread-badge')
+    spreadBadge.textContent = `· spread ${Math.round(m.spread * 100)}¢`
+    cat.appendChild(spreadBadge)
+  }
 
   const q = el('div', 'market-q')
   q.textContent = m.question
@@ -345,11 +495,57 @@ function makeSignalCard(m) {
   const probVal = el('span', `prob-val text-${cls}`)
   probVal.textContent = formatPrice(m.yesPrice)
 
-  const badge = el('span', `signal-badge ${getSignalBadgeClass(sig.signal)}`)
-  badge.textContent = getSignalLabel(sig.signal)
+  if (hasSignal) {
+    const badge = el('span', `signal-badge ${getSignalBadgeClass(sig.signal)}`)
+    badge.textContent = getSignalLabel(sig.signal)
+
+    const trend = getMarketTrend(m.id)
+    if (Math.abs(trend.momentum) > 2 || trend.volatility > 1) {
+      let trendBadgeClass = 'trend-volatile'
+      let trendText = '⚡'
+      if (trend.momentum > 3) { trendBadgeClass = 'trend-bull'; trendText = '▲' }
+      else if (trend.momentum < -3) { trendBadgeClass = 'trend-bear'; trendText = '▼' }
+      else if (trend.volatility > 1.5) { trendBadgeClass = 'trend-volatile'; trendText = '⚡' }
+      const trendBadge = el('span', `trend-badge ${trendBadgeClass}`)
+      trendBadge.textContent = trendText
+      footer.append(probWrap, probVal, badge, trendBadge)
+    } else {
+      footer.append(probWrap, probVal, badge)
+    }
+  } else {
+    const placeholder = el('span', 'signal-badge sig-none')
+    placeholder.textContent = m.analyzable === false ? 'FUERA DE ALCANCE' : 'SIN ANÁLISIS'
+    placeholder.title = m.analyzable === false
+      ? 'La IA no puede aportar edge en este tipo de mercado (deportes, predicciones de palabras, etc.).'
+      : 'Aún no se ha generado una señal para este mercado.'
+    footer.append(probWrap, probVal, placeholder)
+  }
 
-  footer.append(probWrap, probVal, badge)
   card.append(cat, q, footer)
+
+  // Edge row: Mercado vs IA con barra de comparacion
+  if (hasSignal && sig.impliedProb != null && sig.fairProb != null) {
+    const edgeRow = el('div', 'edge-row')
+    const edgePts = sig.edgePoints ?? 0
+    const edgeAbs = Math.abs(edgePts)
+    const edgeDir = edgePts > 0 ? 'pos' : edgePts < 0 ? 'neg' : 'zero'
+
+    const impliedSpan = el('span', 'edge-implied')
+    impliedSpan.textContent = `Mercado ${Math.round(sig.impliedProb * 100)}%`
+
+    const sep1 = el('span', 'edge-sep', '·')
+    const fairSpan = el('span', `edge-fair text-${cls}`)
+    fairSpan.textContent = `IA ${Math.round(sig.fairProb * 100)}%`
+
+    const sep2 = el('span', 'edge-sep', '·')
+    const edgeSpan = el('span', `edge-value edge-${edgeDir}`)
+    const sign = edgePts > 0 ? '+' : edgePts < 0 ? '−' : ''
+    edgeSpan.textContent = `Edge ${sign}${edgeAbs.toFixed(1)}pp`
+
+    edgeRow.append(impliedSpan, sep1, fairSpan, sep2, edgeSpan)
+    card.append(edgeRow)
+  }
+
   card.addEventListener('click', () => selectMarket(card.dataset.market))
   return card
 }
@@ -372,19 +568,23 @@ function attachSignalsObserver(container) {
 
 /* ─── Render signals list ─── */
 function renderSignals() {
+  const filtered = filterMarkets(state.markets, state.filters)
+  renderSignalsFiltered(filtered)
+}
+
+function renderSignalsFiltered(marketsToRender) {
   const container = document.getElementById('signals-list')
   if (!container) return
 
   if (signalsObserver) { signalsObserver.disconnect(); signalsObserver = null }
   container.replaceChildren()
 
-  if (state.markets.length === 0) {
-    container.appendChild(emptyState('No hay mercados disponibles'))
+  if (marketsToRender.length === 0) {
+    container.appendChild(emptyState('No hay mercados que coincidan con los filtros'))
     return
   }
 
-  state.markets.forEach((m) => container.appendChild(makeSignalCard(m)))
-  if (state.signalsHasMore) attachSignalsObserver(container)
+  marketsToRender.forEach((m) => container.appendChild(makeSignalCard(m)))
 }
 
 function appendSignalCards(newMarkets) {
@@ -462,44 +662,43 @@ function buildDetailDOM(m, sig, prefix = '') {
   const metricConf = el('div', 'metric')
   metricConf.append(el('div', 'metric-label', 'Confianza'), confEl)
 
+  // ── SÍ / NO mini chips in header ──
+  const yesMiniPrice = el('div', 'outcome-mini-price yes')
+  yesMiniPrice.textContent = formatPrice(m.yesPrice)
+  const yesMini = el('div', 'outcome-mini')
+  yesMini.append(el('div', 'outcome-mini-label', 'SÍ'), yesMiniPrice)
+
+  const noMiniPrice = el('div', 'outcome-mini-price no')
+  noMiniPrice.textContent = formatPrice(m.noPrice)
+  const noMini = el('div', 'outcome-mini')
+  noMini.append(el('div', 'outcome-mini-label', 'NO'), noMiniPrice)
+
   const metrics = el('div', 'detail-metrics')
-  metrics.append(metricDelta, el('div', 'metric-sep'), metricConf)
+  metrics.append(yesMini, noMini, el('div', 'metric-sep'), metricDelta, el('div', 'metric-sep'), metricConf)
 
   const header = el('div', 'detail-header')
   header.append(headerLeft, metrics)
 
-  // ── Outcomes row ──
-  const sparkYes = el('div', 'sparkline')
-  sparkYes.id = sparkYesId
-  const yesPriceEl = el('div', 'outcome-price')
-  yesPriceEl.textContent = formatPrice(m.yesPrice)
-  const yesDeltaEl = el('div', 'outcome-delta td-green')
-  yesDeltaEl.textContent = `▲ ${((m.yesPrice || 0) * 0.05).toFixed(1)}¢`
-  const yesCard = el('div', 'outcome-card yes')
-  yesCard.append(el('div', 'outcome-name', 'SÍ'), yesPriceEl, yesDeltaEl, sparkYes)
-
-  const sparkNo = el('div', 'sparkline')
-  sparkNo.id = sparkNoId
-  const noPriceEl = el('div', 'outcome-price')
-  noPriceEl.textContent = formatPrice(m.noPrice)
-  const noDeltaEl = el('div', 'outcome-delta td-red')
-  noDeltaEl.textContent = `▼ ${((m.noPrice || 0) * 0.05).toFixed(1)}¢`
-  const noCard = el('div', 'outcome-card no')
-  noCard.append(el('div', 'outcome-name', 'NO'), noPriceEl, noDeltaEl, sparkNo)
-
+  // ── Outcomes row: AI box + chart ──
   const detailChart = el('canvas')
   detailChart.id = chartId
   const chartContainer = el('div', 'chart-container')
   chartContainer.append(el('div', 'chart-label', 'Historial de precios 7d'), detailChart)
 
   const outcomesRow = el('div', 'outcomes-row')
-  outcomesRow.append(yesCard, noCard, chartContainer)
 
   // ── AI box ──
   const aiBadge = el('span', `signal-badge ${getSignalBadgeClass(sig.signal)}`)
   aiBadge.textContent = `${translateSignal(sig.signal).toUpperCase()} · ${Math.round(sig.confidence * 100)}%`
+
+  const modelBadge = el('span', 'model-badge')
+  modelBadge.textContent = sig.modelVersion || 'IA'
+
+  const aiTitleGroup = el('div', 'ai-title-group')
+  aiTitleGroup.append(el('div', 'ai-icon', '◈'), el('div', 'ai-label', 'Análisis IA'), modelBadge)
+
   const aiHeader = el('div', 'flex-between mb-4')
-  aiHeader.append(el('div', 'ai-label', 'Análisis IA'), aiBadge)
+  aiHeader.append(aiTitleGroup, aiBadge)
 
   // Texto IA construido con nodos DOM — ninguna cadena externa toca innerHTML
   const aiText = el('div', 'ai-text')
@@ -510,12 +709,13 @@ function buildDetailDOM(m, sig, prefix = '') {
     aiText.append(' ', strong, ' ', sig.keyRisk)
   }
 
-  const aiInner = el('div', 'flex-1')
-  aiInner.append(aiHeader, aiText)
   const aiBox = el('div', 'ai-box')
-  aiBox.append(el('div', 'ai-icon', '◈'), aiInner)
+  aiBox.append(aiHeader, aiText)
+
+  outcomesRow.append(aiBox, chartContainer)
 
   // ── Simulator row ──
+  // El backend calcula sizing (Kelly cost-aware con spread). Aqui solo lo pintamos.
   const simAmount = el('input', 'sim-input')
   simAmount.type = 'number'
   simAmount.value = '100'
@@ -525,8 +725,12 @@ function buildDetailDOM(m, sig, prefix = '') {
   const simYes = el('button', 'sim-btn-yes', 'COMPRAR SÍ ↗')
   const simNo = el('button', 'sim-btn-no', 'COMPRAR NO')
 
+  const noteRow = el('div', 'kelly-note')
+  noteRow.textContent = 'Calculando sugerencia…'
+
   const simRow = el('div', 'sim-row')
   simRow.append(
+    noteRow,
     el('span', 'sim-label', 'Simular posición →'),
     simAmount,
     simYes,
@@ -537,7 +741,25 @@ function buildDetailDOM(m, sig, prefix = '') {
   simNo.addEventListener('click', () => simulator.openPosition(m.id, 'NO', simAmount.value))
 
   const content = el('div')
-  content.append(header, outcomesRow, aiBox, simRow)
+  content.append(header, outcomesRow, simRow)
+
+  // Fetch async: el backend conoce spread + ultima senal + Kelly conservador
+  api.getPositionSuggestion(m.id).then((sug) => {
+    if (!sug) return
+    if (sug.illiquid) {
+      simYes.disabled = true
+      simNo.disabled = true
+      simYes.title = `Mercado ilíquido (spread ${Math.round((m.spread ?? 0) * 100)}¢).`
+      simNo.title = simYes.title
+      noteRow.classList.add('kelly-warn')
+    }
+    if (sug.amountEur > 0) {
+      simAmount.value = String(sug.amountEur)
+    }
+    noteRow.textContent = sug.note || ''
+  }).catch(() => {
+    noteRow.textContent = ''
+  })
 
   return { content, chartId, sparkYesId, sparkNoId }
 }
@@ -548,7 +770,7 @@ function renderDetail() {
   if (!container) return
   const m = state.markets.find((x) => x.id === state.activeMarketId)
   if (!m) {
-    container.replaceChildren(emptyState('Selecciona un mercado para ver detalles'))
+    container.replaceChildren()
     return
   }
 
@@ -562,7 +784,11 @@ function renderDetail() {
   const { content, chartId, sparkYesId, sparkNoId } = buildDetailDOM(m, sig)
   container.replaceChildren(content)
 
-  charts.renderDetailChart(chartId, m.yesPrice)
+  api.getMarketHistory(m.id).then((history) => {
+    charts.renderDetailChart(chartId, m.yesPrice, history)
+  }).catch(() => {
+    charts.renderDetailChart(chartId, m.yesPrice)
+  })
   charts.renderSparkline(sparkYesId, m.yesPrice, 'yes')
   charts.renderSparkline(sparkNoId, m.noPrice, 'no')
 }
@@ -607,7 +833,11 @@ function selectMarket(marketId) {
     // Charts require the canvas to be in the DOM before rendering.
     // Scroll after paint so the layout height is settled.
     requestAnimationFrame(() => {
-      charts.renderDetailChart(chartId, m.yesPrice)
+      api.getMarketHistory(m.id).then((history) => {
+        charts.renderDetailChart(chartId, m.yesPrice, history)
+      }).catch(() => {
+        charts.renderDetailChart(chartId, m.yesPrice)
+      })
       charts.renderSparkline(sparkYesId, m.yesPrice, 'yes')
       charts.renderSparkline(sparkNoId, m.noPrice, 'no')
 
@@ -789,10 +1019,10 @@ function renderAlerts() {
 /* ─── Carga de datos ─── */
 async function loadMarkets() {
   try {
-    const batch = await api.getMarkets({ limit: 20, offset: 0 })
+    const batch = await api.getMarkets({ limit: 60, offset: 0 })
     state.markets = Array.isArray(batch) ? batch : []
     state.signalsOffset = state.markets.length
-    state.signalsHasMore = state.markets.length === 20
+    state.signalsHasMore = state.markets.length === 60
   } catch (e) {
     console.error('Error cargando mercados:', e)
     state.markets = []
@@ -805,7 +1035,7 @@ async function loadMoreMarkets() {
   if (state.signalsLoading || !state.signalsHasMore) return
   state.signalsLoading = true
   try {
-    const batch = await api.getMarkets({ limit: 20, offset: state.signalsOffset })
+    const batch = await api.getMarkets({ limit: 40, offset: state.signalsOffset })
     const arr = Array.isArray(batch) ? batch : []
     if (arr.length === 0) {
       state.signalsHasMore = false
@@ -814,12 +1044,13 @@ async function loadMoreMarkets() {
     } else {
       state.markets.push(...arr)
       state.signalsOffset += arr.length
-      state.signalsHasMore = arr.length === 20
+      state.signalsHasMore = arr.length === 40
       try {
         const newSigs = await api.getSignalsBatch(arr.map((m) => m.id))
         state.signals.push(...newSigs.map((r) => ({ ...r, marketId: r.marketId })))
       } catch (e) { /* signals are optional */ }
-      appendSignalCards(arr)
+      populateFilters()
+      applyFilters()
     }
   } catch (e) {
     console.error('Error cargando más mercados:', e)
@@ -895,6 +1126,14 @@ async function initAppData() {
   await loadAlerts()
   await loadStats()
 
+  // Inicializar historial de precios para tracking de trends
+  state.markets.forEach((m) => {
+    if (m.yesPrice != null) {
+      recordPrice(m.id, m.yesPrice)
+    }
+  })
+
+  populateFilters()
   map.init('map-container', state.markets, state.signals, selectMarket)
   simulator.init(state)
 
@@ -947,6 +1186,7 @@ export async function init() {
   const authed = await ensureAuth()
   if (authed) {
     await initAppData()
+    initFilters()
   } else {
     openAuthModal()
   }
@@ -958,7 +1198,10 @@ export async function init() {
     const m = state.markets.find((x) => x.id === data.marketId)
     if (m) {
       // Solo copia campos numericos conocidos — nunca mezcle todo el payload
-      if (typeof data.yesPrice === 'number') m.yesPrice = data.yesPrice
+      if (typeof data.yesPrice === 'number') {
+        recordPrice(m.id, data.yesPrice)
+        m.yesPrice = data.yesPrice
+      }
       if (typeof data.noPrice === 'number') m.noPrice = data.noPrice
       if (typeof data.volumeEur === 'number') m.volumeEur = data.volumeEur
       if (typeof data.liquidityEur === 'number') m.liquidityEur = data.liquidityEur

frontend/src/charts.js

@@ -17,24 +17,42 @@ import { Chart } from 'chart.js/auto'
 
 let detailChartInstance = null
 
-export function renderDetailChart(canvasId, currentPrice) {
+export function renderDetailChart(canvasId, currentPrice, history = []) {
   const ctx = document.getElementById(canvasId)
   if (!ctx) return
   if (detailChartInstance) detailChartInstance.destroy()
 
-  const base = currentPrice * 100
-  const pts = Array.from({ length: 8 }, (_, i) => {
-    const noise = (Math.random() - 0.5) * 8
-    return Math.max(5, Math.min(95, base - 12 + (i / 7) * 12 + noise))
-  })
-  pts[pts.length - 1] = base
+  const container = ctx.parentElement
+  if (container) {
+    const labelEl = container.querySelector('.chart-label')
+    const labelH = labelEl ? labelEl.offsetHeight + 6 : 24
+    ctx.style.height = `${container.clientHeight - labelH - 28}px`
+  }
+
+  let pts, labels
+  if (history.length >= 2) {
+    pts = history.map((h) => +(h.p * 100).toFixed(2))
+    labels = history.map((h) => {
+      const d = new Date(h.t * 1000)
+      return `${d.getMonth() + 1}/${d.getDate()} ${d.getHours()}h`
+    })
+  } else {
+    const base = currentPrice * 100
+    pts = Array.from({ length: 8 }, (_, i) => {
+      const noise = (Math.random() - 0.5) * 8
+      return Math.max(5, Math.min(95, base - 12 + (i / 7) * 12 + noise))
+    })
+    pts[pts.length - 1] = base
+    labels = ['7d', '6d', '5d', '4d', '3d', '2d', '1d', 'ahora']
+  }
 
-  const col = base > 50 ? '#22d37a' : base < 40 ? '#f04040' : '#f0a020'
+  const last = pts[pts.length - 1]
+  const col = last > 50 ? '#22d37a' : last < 40 ? '#f04040' : '#f0a020'
 
   detailChartInstance = new Chart(ctx, {
     type: 'line',
     data: {
-      labels: ['7d', '6d', '5d', '4d', '3d', '2d', '1d', 'now'],
+      labels,
       datasets: [
         {
           data: pts,

frontend/src/filters.js

@@ -0,0 +1,28 @@
+/**
+ * Utilidades de filtrado para el dashboard.
+ *
+ * Expone funciones para extraer opciones unicas de filtros desde mercados.
+ */
+
+// ── Extractores de opciones de filtro ─────────────────────────────────────────
+
+export function extractFilterOptions(markets) {
+  const categories = new Set()
+
+  for (const m of markets) {
+    if (m.category) categories.add(m.category)
+  }
+
+  return {
+    categories: ['Todas', ...Array.from(categories).sort()],
+  }
+}
+
+// ── Filtrado ──────────────────────────────────────────────────────────────────
+
+export function filterMarkets(markets, { category }) {
+  return markets.filter((m) => {
+    if (category && category !== 'Todas' && m.category !== category) return false
+    return true
+  })
+}

frontend/src/map.js

@@ -28,17 +28,134 @@ import { getCoordsByCode, detectCountryInText } from './capitals.js'
 let mapInstance = null
 let bubbles = {} // marketId -> marcador de circulo
 
+// Hubs globales para mercados sin pais. Cubre TODOS los continentes para
+// que las bubbles no se concentren en US/EU/Asia. Cada hub tiene tambien un
+// "spread" propio para que multiples markets en el mismo hub se repartan.
+const FINANCIAL_HUBS = [
+  // America del Norte
+  [40.71, -74.0],    // Nueva York
+  [37.77, -122.42],  // San Francisco
+  [41.88, -87.63],   // Chicago
+  [43.65, -79.38],   // Toronto
+  [19.43, -99.13],   // Ciudad de Mexico
+  // America Latina
+  [-23.55, -46.63],  // Sao Paulo
+  [-34.61, -58.38],  // Buenos Aires
+  [-33.45, -70.66],  // Santiago de Chile
+  [4.71, -74.07],    // Bogota
+  [10.49, -66.88],   // Caracas
+  // Europa
+  [51.5, -0.13],     // Londres
+  [50.11, 8.68],     // Frankfurt
+  [48.85, 2.35],     // Paris
+  [40.42, -3.7],     // Madrid
+  [41.9, 12.5],      // Roma
+  [47.37, 8.54],     // Zurich
+  [52.37, 4.9],      // Amsterdam
+  [55.75, 37.62],    // Moscu
+  [50.45, 30.52],    // Kyiv
+  [41.0, 28.98],     // Estambul
+  // Africa
+  [-26.2, 28.05],    // Johannesburgo
+  [6.45, 3.4],       // Lagos
+  [30.04, 31.24],    // Cairo
+  [-1.29, 36.82],    // Nairobi
+  [33.97, -6.85],    // Rabat
+  // Oriente Medio
+  [25.2, 55.27],     // Dubai
+  [24.71, 46.68],    // Riad
+  [32.07, 34.78],    // Tel Aviv
+  // Asia
+  [22.3, 114.17],    // Hong Kong
+  [35.68, 139.69],   // Tokio
+  [1.35, 103.82],    // Singapur
+  [31.23, 121.47],   // Shanghai
+  [19.08, 72.88],    // Mumbai
+  [37.57, 126.98],   // Seul
+  [13.76, 100.5],    // Bangkok
+  [-6.21, 106.85],   // Yakarta
+  [25.03, 121.56],   // Taipei
+  // Oceania
+  [-33.87, 151.21],  // Sydney
+  [-37.81, 144.96],  // Melbourne
+  [-36.85, 174.76],  // Auckland
+]
+
+// Hash determinista para jitter reproducible por marketId
+function hashCode(str) {
+  let h = 0
+  const s = String(str)
+  for (let i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0
+  return Math.abs(h)
+}
+
+// Tamano aproximado de cada pais (radio en grados, lat/lng).
+// Paises grandes → mas jitter para repartir bubbles por su territorio.
+// Default 3.5° si no esta listado.
+// Bounding-box approximado de cada pais (semi-eje lat, semi-eje lng en grados).
+// Paises grandes → caja grande para repartir las bubbles por todo el territorio.
+const COUNTRY_JITTER = {
+  US: [14, 32],   // EEUU: NY (-74) a LA (-118), TX (29) a MN (49)
+  RU: [12, 55],   // Rusia: cruza 11 husos horarios
+  CA: [11, 35],
+  CN: [13, 25],
+  BR: [13, 18],
+  AU: [11, 22],
+  IN: [10, 14],
+  AR: [14, 10],
+  MX: [8, 13],
+  KZ: [7, 22],
+  DZ: [10, 11],
+  SA: [9, 11],
+  CD: [9, 9],
+  GB: [4, 4],
+  DE: [4, 5],
+  FR: [5, 5],
+  ES: [5, 6],
+  IT: [5, 5],
+  JP: [6, 8],
+  TR: [4, 9],
+  IR: [7, 9],
+  IL: [1.2, 1.2],
+  UA: [5, 9],
+  KR: [2.5, 2.5],
+  ZA: [6, 8],
+  NG: [5, 6],
+  EG: [5, 6],
+  ID: [6, 22],
+}
+
+// Distribucion UNIFORME en un rectangulo (no en elipse polar, que clumpea
+// hacia el centro). Cada market id mapea a un (dx,dy) deterministico que
+// cubre toda la bounding box del pais.
+function jitter(coords, marketId, amount = 4) {
+  const h = hashCode(marketId)
+  const [latR, lngR] = Array.isArray(amount) ? amount : [amount, amount]
+  // Dos canales de 16 bits del hash → coordenadas uniformes en [-1, 1]
+  const u = ((h & 0xFFFF) / 0xFFFF) * 2 - 1
+  const v = (((h >> 16) & 0xFFFF) / 0xFFFF) * 2 - 1
+  return [coords[0] + v * latR, coords[1] + u * lngR]
+}
+
+function pickFinancialHub(marketId) {
+  const idx = hashCode(marketId) % FINANCIAL_HUBS.length
+  return FINANCIAL_HUBS[idx]
+}
+
 function getCoords(market) {
-  // 1. intentar por countryCode ISO2 del mercado
+  // 1. countryCode ISO2 explicito + jitter proporcional al tamano del pais
   const byCode = getCoordsByCode(market.countryCode)
-  if (byCode) return byCode
+  if (byCode) {
+    const amount = COUNTRY_JITTER[market.countryCode] || 3.5
+    return jitter(byCode, market.id, amount)
+  }
 
-  // 2. fallback: detectar país en el texto de la pregunta
+  // 2. heuristica de texto: detectamos el codigo y reaplicamos el lookup
   const byText = detectCountryInText(market.question)
-  if (byText) return byText
+  if (byText) return jitter(byText, market.id, 4)
 
-  // 3. default centrado en África (coordenadas genéricas)
-  return [20, 0]
+  // 3. mercado sin pais: distribuir entre hubs financieros globales
+  return jitter(pickFinancialHub(market.id), market.id, 3)
 }
 
 function getSignalColor(signal) {
@@ -57,6 +174,7 @@ function getRadius(volumeEur) {
 }
 
 export function init(containerId, markets, signals, onSelect) {
+  window.__onSelectMarket = onSelect
   const container = document.getElementById(containerId)
   if (!container) return
 
@@ -142,7 +260,7 @@ export function init(containerId, markets, signals, onSelect) {
   })
 }
 
-export function updateBubble(marketId, newPrice) {
+export function updateBubble(marketId) {
   const b = bubbles[marketId]
   if (!b) return
   // Ajusta ligeramente el radio basado en nueva actividad (comportamiento simulado)
@@ -160,3 +278,80 @@ export function highlightMarket(marketId) {
     b.circle.openPopup()
   }
 }
+
+export function updateMarkers(markets, signals) {
+  if (!mapInstance) return
+
+  // Limpiar burbujas existentes
+  Object.values(bubbles).forEach((b) => {
+    mapInstance.removeLayer(b.circle)
+    mapInstance.removeLayer(b.inner)
+    mapInstance.removeLayer(b.label)
+  })
+  bubbles = {}
+
+  // Re-renderizar solo los mercados filtrados
+  markets.forEach((m) => {
+    const sig = signals.find((s) => s.marketId === m.id) || { signal: 'neutral' }
+    const color = getSignalColor(sig.signal)
+    const coords = getCoords(m)
+    const radius = getRadius(m.volumeEur)
+
+    const circle = L.circleMarker(coords, {
+      radius,
+      fillColor: color,
+      color: color,
+      weight: 1.5,
+      opacity: 0.6,
+      fillOpacity: 0.22,
+    }).addTo(mapInstance)
+
+    const inner = L.circleMarker(coords, {
+      radius: Math.max(3, radius * 0.45),
+      fillColor: color,
+      color: 'transparent',
+      fillOpacity: 0.8,
+      interactive: false,
+    }).addTo(mapInstance)
+
+    const labelSpan = document.createElement('span')
+    labelSpan.className = 'map-label-text'
+    labelSpan.textContent = m.countryCode || 'GL'
+
+    const label = L.marker(coords, {
+      icon: L.divIcon({
+        className: 'map-label',
+        html: labelSpan.outerHTML,
+        iconSize: [40, 14],
+        iconAnchor: [20, -radius - 4],
+      }),
+      interactive: false,
+    }).addTo(mapInstance)
+
+    const popup = document.createElement('div')
+    popup.className = 'map-popup'
+    const popupCat = document.createElement('div')
+    popupCat.className = 'map-popup-cat'
+    popupCat.textContent = `${m.category || 'General'} · ${m.countryCode || 'GL'}`
+    const popupQ = document.createElement('div')
+    popupQ.className = 'map-popup-q'
+    popupQ.textContent = m.question
+    const popupPrices = document.createElement('div')
+    popupPrices.className = 'map-popup-prices'
+    const yesSpan = document.createElement('span')
+    yesSpan.className = 'text-green'
+    yesSpan.textContent = `SÍ ${Math.round((m.yesPrice || 0) * 100)}¢`
+    const noSpan = document.createElement('span')
+    noSpan.className = 'text-red'
+    noSpan.textContent = `NO ${Math.round((m.noPrice || 0) * 100)}¢`
+    popupPrices.append(yesSpan, noSpan)
+    popup.append(popupCat, popupQ, popupPrices)
+    circle.bindPopup(popup, { closeButton: false, offset: [0, -4] })
+
+    circle.on('click', () => {
+      if (window.__onSelectMarket) window.__onSelectMarket(m.id)
+    })
+
+    bubbles[m.id] = { circle, inner, label, color }
+  })
+}

frontend/src/style.css

@@ -306,6 +306,47 @@ h6 { font-size: var(--fs-h6); line-height: 1.4;  font-weight: 500; }
 .stat-delta.dn { color: var(--red); }
 .stat-delta.neutral { color: var(--text3); }
 
+.topbar-filters {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-shrink: 0;
+}
+
+.filter-select {
+  background: var(--bg3);
+  border: 0.5px solid var(--border2);
+  border-radius: var(--radius-sm);
+  padding: 7px 12px;
+  color: var(--text);
+  font-size: 0.875rem;
+  font-family: var(--font-mono);
+  outline: none;
+  cursor: pointer;
+  min-width: 140px;
+  max-width: 180px;
+  appearance: none;
+  -webkit-appearance: none;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%238b90a0' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'%3E%3C/polyline%3E%3C/svg%3E");
+  background-repeat: no-repeat;
+  background-position: right 10px center;
+  padding-right: 30px;
+  transition: border-color 0.15s;
+}
+
+.filter-select:hover {
+  border-color: var(--border2);
+}
+
+.filter-select:focus {
+  border-color: var(--blue2);
+}
+
+.filter-select option {
+  background: var(--bg2);
+  color: var(--text);
+}
+
 .topbar-actions {
   margin-left: auto;
   display: flex;
@@ -367,7 +408,7 @@ h6 { font-size: var(--fs-h6); line-height: 1.4;  font-weight: 500; }
 .dashboard-grid {
   display: grid;
   grid-template-columns: 1fr 336px;
-  grid-template-rows: 1fr minmax(280px, 40%);
+  grid-template-rows: minmax(120px, 59%) 1fr;
   gap: var(--panel-gap);
   height: 100%;
   min-height: 0;
@@ -472,11 +513,11 @@ h6 { font-size: var(--fs-h6); line-height: 1.4;  font-weight: 500; }
   display: flex;
   align-items: center;
   gap: 12px;
+  margin-left: auto;
 }
 
-/* Always pin the toggle to the far right of the map panel header */
-#panel-map .panel-header .panel-toggle {
-  margin-left: auto;
+#panel-map .panel-header {
+  justify-content: flex-start;
 }
 
 /* Panel mapa */
@@ -587,17 +628,97 @@ h6 { font-size: var(--fs-h6); line-height: 1.4;  font-weight: 500; }
 .sig-bull { background: var(--green3); color: var(--green); border: 0.5px solid var(--green2); }
 .sig-bear { background: var(--red3); color: var(--red); border: 0.5px solid var(--red2); }
 .sig-neut { background: var(--bg4); color: var(--text2); border: 0.5px solid var(--border2); }
+.sig-none {
+  background: transparent;
+  color: var(--text3, #6e7681);
+  border: 0.5px dashed var(--border2);
+  font-size: 0.72rem;
+  letter-spacing: 0.06em;
+  font-weight: 500;
+}
+
+.model-badge {
+  font-size: 0.65rem;
+  font-weight: 500;
+  color: var(--text3, #6e7681);
+  background: var(--bg4);
+  border: 0.5px solid var(--border2);
+  border-radius: 4px;
+  padding: 1px 5px;
+  margin-left: 6px;
+  font-family: var(--font-mono);
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  flex-shrink: 0;
+}
+
+/* Spread badge inline en categoria */
+.spread-badge {
+  margin-left: 6px;
+  font-size: 0.7rem;
+  color: var(--text3, #6e7681);
+  font-family: var(--font-mono);
+}
+.spread-badge.illiquid {
+  color: var(--red, #f04040);
+  font-weight: 600;
+}
+
+/* Fila Edge: Mercado · IA · Edge */
+.edge-row {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 6px;
+  padding-top: 6px;
+  border-top: 0.5px solid var(--border2, #1f242b);
+  font-size: 0.72rem;
+  font-family: var(--font-mono);
+  letter-spacing: 0.02em;
+}
+.edge-implied { color: var(--text2, #9aa4b2); }
+.edge-fair { font-weight: 600; }
+.edge-sep { color: var(--text3, #4a5260); opacity: 0.6; }
+.edge-value { font-weight: 700; padding: 1px 5px; border-radius: 3px; }
+.edge-pos { color: var(--green, #22d37a); background: var(--green3, rgba(34,211,122,0.08)); }
+.edge-neg { color: var(--red, #f04040); background: var(--red3, rgba(240,64,64,0.08)); }
+.edge-zero { color: var(--text3, #6e7681); }
+
+/* Sugerencia de tamano (Kelly) bajo el simulador */
+.kelly-note {
+  flex: 1;
+  font-size: 0.78rem;
+  color: var(--text2, #9aa4b2);
+  font-family: var(--font-mono);
+  padding: 4px 8px;
+  border-left: 2px solid var(--border2, #1f242b);
+  background: rgba(255,255,255,0.02);
+  border-radius: 0 4px 4px 0;
+}
+.kelly-warn {
+  color: var(--red, #f04040);
+  border-left-color: var(--red, #f04040);
+  background: rgba(240,64,64,0.05);
+}
 
 /* Panel detalle */
 .detail-panel {
   grid-row: 2 / 3;
   grid-column: 1 / 2;
-  max-height: 100%;
   overflow: hidden;
 }
 
 .detail-panel .panel-body {
-  overflow-y: auto;
+  overflow: hidden;
+}
+
+/* The anonymous content wrapper built by buildDetailDOM */
+.detail-panel .panel-body > div {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  min-height: 0;
 }
 
 .detail-header {
@@ -664,7 +785,8 @@ h6 { font-size: var(--fs-h6); line-height: 1.4;  font-weight: 500; }
 .outcomes-row {
   display: flex;
   gap: 16px;
-  margin-bottom: 12px;
+  flex: 1;
+  min-height: 0;
 }
 
 .outcome-card {
@@ -705,15 +827,11 @@ h6 { font-size: var(--fs-h6); line-height: 1.4;  font-weight: 500; }
   border: 0.5px solid var(--border);
   border-radius: var(--radius-sm);
   padding: 14px;
-  min-height: 120px;
-  height: 160px;
-  max-height: 160px;
+  min-height: 80px;
   overflow: hidden;
+  align-self: stretch;
 }
 
-.chart-container canvas {
-  max-height: 130px;
-}
 
 .chart-label {
   font-size: 0.875rem;
@@ -722,15 +840,55 @@ h6 { font-size: var(--fs-h6); line-height: 1.4;  font-weight: 500; }
   margin-bottom: 6px;
 }
 
+/* SÍ / NO mini chips in the detail header */
+.outcome-mini {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 2px;
+  padding: 0 10px;
+}
+
+.outcome-mini-label {
+  font-size: 0.72rem;
+  font-family: var(--font-mono);
+  color: var(--text3);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+
+.outcome-mini-price {
+  font-size: 1rem;
+  font-weight: 700;
+  font-family: var(--font-mono);
+}
+
+.outcome-mini-price.yes { color: var(--green); }
+.outcome-mini-price.no  { color: var(--red); }
+
+.ai-title-group {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.ai-title-group .ai-icon {
+  width: 20px;
+  height: 20px;
+  font-size: 0.75rem;
+}
+
 .ai-box {
+  flex: 1;
   background: var(--bg3);
   border: 0.5px solid var(--blue2);
   border-radius: var(--radius-sm);
   padding: 14px;
   display: flex;
-  gap: 14px;
-  align-items: flex-start;
-  margin-bottom: 10px;
+  flex-direction: column;
+  gap: 8px;
+  overflow: hidden;
+  min-width: 0;
 }
 
 .ai-icon {
@@ -1458,6 +1616,58 @@ td {
   font-size: 0.875rem;
 }
 
+/* ─── Trend Select ─── */
+#filter-trend {
+  min-width: 170px;
+  background: var(--bg3);
+  border: 0.5px solid var(--amber2);
+  color: var(--amber);
+}
+
+#filter-trend:focus {
+  border-color: var(--amber);
+}
+
+#filter-trend option {
+  background: var(--bg2);
+  color: var(--text);
+}
+
+/* ─── Trend Badges ─── */
+.trend-badge {
+  font-size: 0.75rem;
+  font-weight: 600;
+  padding: 2px 6px;
+  border-radius: 4px;
+  font-family: var(--font-mono);
+  letter-spacing: 0.04em;
+  margin-left: 8px;
+}
+
+.trend-hot {
+  background: rgba(240, 160, 32, 0.15);
+  color: var(--amber);
+  border: 0.5px solid var(--amber2);
+}
+
+.trend-bull {
+  background: var(--green3);
+  color: var(--green);
+  border: 0.5px solid var(--green2);
+}
+
+.trend-bear {
+  background: var(--red3);
+  color: var(--red);
+  border: 0.5px solid var(--red2);
+}
+
+.trend-volatile {
+  background: rgba(74, 158, 255, 0.15);
+  color: var(--blue);
+  border: 0.5px solid var(--blue2);
+}
+
 /* ─── Responsive ─── */
 @media (max-width: 1024px) {
   * {