Add files using upload-large-folder tool

backend/src/alerts/alerts.controller.js

@@ -0,0 +1,19 @@
+/**
+ * Controladores del modulo de alertas.
+ *
+ * Responsabilidades:
+ *   - list(req, res) → devuelve el historial de alertas del usuario autenticado.
+ *
+ * Endpoint (bajo /api/v1/alerts, protegido por requireAuth):
+ *   GET / → lista paginada de alertas.
+ */
+
+import { ok } from '../utils/apiResponse.js';
+import { alertsService } from './alerts.service.js';
+
+export const alertsController = {
+  async list(req, res) {
+    const alerts = await alertsService.list(req.user.id, req.query);
+    ok(res, alerts);
+  },
+};

backend/src/alerts/alerts.repository.js

@@ -0,0 +1,37 @@
+/**
+ * Repositorio de acceso a datos para el modelo Alert.
+ *
+ * Responsabilidades:
+ *   - create(data)       → inserta una nueva alerta.
+ *   - findByUser(...)    → alertas paginadas del usuario con datos del mercado.
+ *   - findRecent(...)    → busca alerta reciente en ventana de tiempo (deduplicacion).
+ *
+ * Campos:
+ *   type (price_threshold|signal_change), message, sentAt.
+ *
+ * Todas las operaciones usan Prisma ORM.
+ */
+
+import { prisma } from '../utils/prisma.js';
+
+export const alertsRepository = {
+  create({ userId, marketId, type, message }) {
+    return prisma.alert.create({ data: { userId, marketId, type, message } });
+  },
+
+  findByUser(userId, { limit = 50, offset = 0 } = {}) {
+    return prisma.alert.findMany({
+      where: { userId },
+      orderBy: { sentAt: 'desc' },
+      take: limit,
+      skip: offset,
+      include: { market: { select: { id: true, question: true } } },
+    });
+  },
+
+  findRecent(userId, marketId, type, windowMs) {
+    return prisma.alert.findFirst({
+      where: { userId, marketId, type, sentAt: { gte: new Date(Date.now() - windowMs) } },
+    });
+  },
+};

backend/src/alerts/alerts.routes.js

@@ -0,0 +1,20 @@
+/**
+ * Rutas REST del modulo de alertas.
+ *
+ * Endpoint (montado en /api/v1/alerts):
+ *   GET / → listar alertas del usuario autenticado.
+ *
+ * Requiere autenticacion JWT (router.use(requireAuth)).
+ */
+
+import { Router } from 'express';
+import { requireAuth } from '../middlewares/requireAuth.js';
+import { alertsController } from './alerts.controller.js';
+
+const router = Router();
+
+router.use(requireAuth);
+
+router.get('/', alertsController.list);
+
+export default router;

backend/src/alerts/alerts.service.js

@@ -0,0 +1,60 @@
+/**
+ * Logica de negocio del modulo de alertas.
+ *
+ * Responsabilidades:
+ *   - list(userId, query) → devuelve alertas paginadas del usuario.
+ *   - processAll()        → revisa la watchlist cada 60s (scheduler):
+ *       1. Obtiene entradas de watchlist con alertThreshold.
+ *       2. Si yesPrice >= alertThreshold y no hay alerta reciente (5 min dedup):
+ *          - Crea alerta en base de datos.
+ *          - Envía mensaje por Telegram (si hay bot token y chatId).
+ *          - Emite evento 'price_alert' por Socket.io.
+ *
+ * Tipos de alerta:
+ *   - price_threshold : umbral de precio cruzado.
+ *   - signal_change   : cambio de senal IA (reservado para futuras versiones).
+ *
+ * Consumido por:
+ *   - alerts.controller.js (API REST).
+ *   - scheduler.js (processAlerts cada 60s).
+ */
+
+import { z } from 'zod';
+import { alertsRepository } from './alerts.repository.js';
+import { watchlistRepository } from '../watchlist/watchlist.repository.js';
+import { sendMessage, formatPriceAlert } from './telegram.client.js';
+import { emitPriceAlert } from '../socket/broadcaster.js';
+import { logger } from '../utils/logger.js';
+
+const listQuery = z.object({
+  limit: z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.coerce.number().int().min(0).default(0),
+});
+
+const DEDUP_WINDOW_MS = 5 * 60 * 1000; // 5 min
+
+export const alertsService = {
+  list(userId, query) {
+    const { limit, offset } = listQuery.parse(query);
+    return alertsRepository.findByUser(userId, { limit, offset });
+  },
+
+  async processAll() {
+    const entries = await watchlistRepository.findAllWithThreshold();
+
+    for (const entry of entries) {
+      const { alertThreshold, user, market } = entry;
+      if (!market.yesPrice || market.yesPrice < alertThreshold) continue;
+
+      const recent = await alertsRepository.findRecent(user.id, market.id, 'price_threshold', DEDUP_WINDOW_MS);
+      if (recent) continue;
+
+      const message = formatPriceAlert(market.question, market.yesPrice, alertThreshold);
+
+      await alertsRepository.create({ userId: user.id, marketId: market.id, type: 'price_threshold', message });
+      await sendMessage(user.telegramChatId, message);
+      emitPriceAlert({ marketId: market.id, type: 'price_threshold', message });
+      logger.info({ marketId: market.id, userId: user.id }, 'price alert sent');
+    }
+  },
+};

backend/src/alerts/telegram.client.js

@@ -0,0 +1,60 @@
+/**
+ * Cliente de integracion con Telegram Bot API.
+ *
+ * Responsabilidades:
+ *   - sendMessage(chatId, text) → POST a api.telegram.org/bot<TOKEN>/sendMessage.
+ *   - formatPriceAlert(question, yesPrice, threshold) → construye mensaje HTML
+ *     escapando entidades del input de usuario.
+ *   - escapeHtml(text) → escapa caracteres HTML sensibles (&, <, >, ").
+ *   - Parse_mode: HTML (permite formato basico: <b>, <i>).
+ *   - Si falta TELEGRAM_BOT_TOKEN o chatId, sendMessage retorna silenciosamente.
+ *   - Errores de red se capturan y loguean como warn (no bloquean el flujo).
+ *   - Respuestas de Telegram con ok: false se loguean como warn y no lanzan excepcion.
+ *
+ * Consumido por:
+ *   - alerts.service.js → processAll() cuando se dispara una alerta.
+ *
+ * Seguridad:
+ *   - El token se lee de variables de entorno (nunca hardcodeado).
+ *   - Todo texto dinamico se escapa via escapeHtml antes de inyectarse en HTML.
+ */
+
+import { httpPost } from '../utils/httpClient.js';
+import { config } from '../config.js';
+import { logger } from '../utils/logger.js';
+
+export function escapeHtml(text) {
+  if (typeof text !== 'string') return String(text ?? '');
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+export function formatPriceAlert(question, yesPrice, threshold) {
+  const safeQuestion = escapeHtml(question);
+  const pct = (yesPrice * 100).toFixed(1);
+  const thr = (threshold * 100).toFixed(1);
+  return `<b>Price Alert</b>\n${safeQuestion}\nYES: ${pct}% ≥ threshold ${thr}%`;
+}
+
+export async function sendMessage(chatId, text) {
+  if (!config.TELEGRAM_BOT_TOKEN || !chatId) return;
+  try {
+    const result = await httpPost(
+      `https://api.telegram.org/bot${config.TELEGRAM_BOT_TOKEN}/sendMessage`,
+      { chat_id: chatId, text, parse_mode: 'HTML' },
+      { retries: 1, timeout: 8_000 },
+    );
+    if (result && result.ok === false) {
+      logger.warn(
+        { chatId, description: result.description, errorCode: result.error_code },
+        'telegram API returned ok=false',
+      );
+      return;
+    }
+  } catch (err) {
+    logger.warn({ err: err.message, chatId }, 'telegram send failed');
+  }
+}

backend/src/finnhub/finnhub.client.js

@@ -0,0 +1,126 @@
+/**
+ * Cliente HTTP de integracion con Finnhub REST API.
+ *
+ * Responsabilidades:
+ *   - Realizar peticiones GET a los endpoints de Finnhub usando httpClient.js
+ *     para obtener retry, timeout y manejo de errores automatico.
+ *   - getCompanyNews(symbol, daysBack)  → noticias de empresa en rango de fechas.
+ *   - getMarketNews(category, limit)  → noticias generales por categoria.
+ *
+ * Restricciones:
+ *   - Free tier: maximo 60 llamadas/minuto.
+ *   - Solo se invoca durante la generacion de senales (cada 5 min).
+ *   - Si FINNHUB_API_KEY no esta configurada, devuelve array vacio.
+ *
+ * Consumido por:
+ *   - finnhub.service.js → fetchFinancialNews(), pipeline de IA.
+ */
+
+import { httpGet } from '../utils/httpClient.js';
+import { config } from '../config.js';
+import { logger } from '../utils/logger.js';
+
+const FINNHUB_API_URL = 'https://finnhub.io/api/v1';
+const API_KEY = config.FINNHUB_API_KEY ?? '';
+
+// Rate limiter interno: maximo 60 llamadas por minuto a Finnhub
+const MAX_CALLS_PER_MINUTE = 60;
+let callTimestamps = [];
+
+function canMakeCall() {
+  const now = Date.now();
+  const oneMinuteAgo = now - 60_000;
+  callTimestamps = callTimestamps.filter((ts) => ts > oneMinuteAgo);
+  return callTimestamps.length < MAX_CALLS_PER_MINUTE;
+}
+
+function recordCall() {
+  callTimestamps.push(Date.now());
+}
+
+function ensureApiKey() {
+  return !!API_KEY;
+}
+
+/**
+ * Normaliza un item de noticia de Finnhub a formato estandar interno.
+ *
+ * @param {Object} item
+ * @returns {Object}
+ */
+function normalizeItem(item) {
+  return {
+    id: item.id || item.url || null,
+    headline: item.headline || item.title || '',
+    summary: item.summary || '',
+    url: item.url || null,
+    source: item.source || null,
+    related: item.related || null,
+    datetime: item.datetime ? new Date(item.datetime * 1000) : null,
+  };
+}
+
+/**
+ * Obtiene noticias de una empresa especifica en un rango de fechas.
+ *
+ * @param {string} symbol - Simbolo bursatil (ej: AAPL, TSLA).
+ * @param {number} [daysBack=7] - Dias hacia atras.
+ * @returns {Promise<Object[]>} Noticias normalizadas (array vacio si no hay API key o se excede rate limit).
+ */
+export async function getCompanyNews(symbol, daysBack = 7) {
+  if (!ensureApiKey()) {
+    logger.debug('Finnhub API key not configured, returning empty array');
+    return [];
+  }
+  if (!canMakeCall()) {
+    logger.warn('Finnhub rate limit exceeded (60 calls/min), returning empty array');
+    return [];
+  }
+
+  const to = new Date();
+  const from = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1000);
+  const fromStr = from.toISOString().slice(0, 10);
+  const toStr = to.toISOString().slice(0, 10);
+
+  const url = `${FINNHUB_API_URL}/company-news?symbol=${encodeURIComponent(symbol)}&from=${fromStr}&to=${toStr}&token=${API_KEY}`;
+
+  try {
+    recordCall();
+    const data = await httpGet(url, { timeout: 10_000, retries: 1 });
+    if (!Array.isArray(data)) return [];
+    return data.map(normalizeItem);
+  } catch (err) {
+    logger.warn({ err: err.message, symbol }, 'Finnhub getCompanyNews failed');
+    return [];
+  }
+}
+
+/**
+ * Obtiene noticias del mercado por categoria.
+ *
+ * @param {string} [category='general'] - Categoria: general, forex, crypto, merger.
+ * @param {number} [limit=50] - Maximo de noticias.
+ * @returns {Promise<Object[]>} Noticias normalizadas (array vacio si no hay API key o se excede rate limit).
+ */
+export async function getMarketNews(category = 'general', limit = 50) {
+  if (!ensureApiKey()) {
+    logger.debug('Finnhub API key not configured, returning empty array');
+    return [];
+  }
+  if (!canMakeCall()) {
+    logger.warn('Finnhub rate limit exceeded (60 calls/min), returning empty array');
+    return [];
+  }
+
+  const url = `${FINNHUB_API_URL}/news?category=${encodeURIComponent(category)}&token=${API_KEY}`;
+
+  try {
+    recordCall();
+    const data = await httpGet(url, { timeout: 10_000, retries: 1 });
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, limit).map(normalizeItem);
+  } catch (err) {
+    logger.warn({ err: err.message, category }, 'Finnhub getMarketNews failed');
+    return [];
+  }
+}

backend/src/finnhub/finnhub.service.js

@@ -0,0 +1,502 @@
+/**
+ * Logica de negocio del modulo de noticias Finnhub.
+ *
+ * Responsabilidades:
+ *   - 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.
+ *
+ * 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.
+ */
+
+import { getCompanyNews, getMarketNews } from './finnhub.client.js';
+import { logger } from '../utils/logger.js';
+
+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'],
+};
+
+/**
+ * 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([
+    'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+    'of', 'with', 'by', 'from', 'up', 'about', 'into', 'through', 'during',
+    'before', 'after', 'above', 'below', 'between', 'among', 'is', 'are',
+    'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does',
+    'did', 'will', 'would', 'could', 'should', 'may', 'might', 'must', 'shall',
+    'can', 'need', 'dare', 'ought', 'used', 'won', 'would', 'it', 'this',
+    'that', 'these', 'those', 'i', 'you', 'he', 'she', 'we', 'they', 'me',
+    'him', 'her', 'us', 'them', 'my', 'your', 'his', 'her', 'its', 'our',
+    'their', 'what', 'which', 'who', 'whom', 'whose', 'where', 'when', 'why',
+    'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other',
+    'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than',
+    'too', 'very', 'just', 'now', 'then', 'here', 'there', 'once', 'again',
+    'further', 'once', 'also', 'back', 'still', 'yet', 'already', 'almost',
+    'quite', 'rather', 'really', 'soon', 'today', 'tomorrow', 'yesterday',
+    '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',
+    'ha', 'han', 'habia', 'haya', 'hizo', 'hace', 'hacia', 'tiene', 'tienen',
+    'tuvo', 'tendria', 'puede', 'podria', 'debe', 'necesita', 'quiere', 'cada',
+    'algun', 'alguna', 'algunos', 'algunas', 'todo', 'toda', 'todos', 'todas',
+    'muy', 'mas', 'menos', 'mucho', 'muchos', 'poco', 'pocos', 'bastante',
+    'demasiado', 'casi', 'solo', 'solamente', 'tambien', 'aun', 'ya', 'todavia',
+    'siempre', 'nunca', 'jamás', 'ahora', 'hoy', 'manana', 'ayer', 'aqui', 'alli',
+    'alli', 'luego', 'entonces', 'asi', 'como', 'cuando', 'donde', 'porque',
+    'por que', 'quien', 'cual', 'cuales', 'cuanto', 'cuanta', 'cuantos', 'cuantas',
+  ]);
+
+  return question
+    .toLowerCase()
+    .replace(/[^\w\s]/g, ' ')
+    .split(/\s+/)
+    .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 ────────────────────────────────────────────────────────────────
+
+/**
+ * Obtiene noticias financieras RELEVANTES para un mercado especifico.
+ *
+ * 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} market - Mercado de Polymarket ({ question })
+ * @returns {Promise<Object[]>} Noticias relevantes o array vacio.
+ */
+export async function fetchFinancialNewsForMarket(market) {
+  if (!market || !market.question) return [];
+
+  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 (macro).
+ * Rota entre multiples categorias para variedad.
+ */
+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);
+}
+
+/**
+ * Filtra noticias por relevancia respecto a una pregunta de mercado.
+ *
+ * @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 = [],
+  daysBack = 7,
+  limitPerSymbol = 20,
+} = {}) {
+  if (!symbols.length) return [];
+
+  const allNews = [];
+  for (const symbol of symbols.slice(0, 5)) {
+    try {
+      const items = await getCompanyNews(symbol, daysBack);
+      allNews.push(...items.slice(0, limitPerSymbol).map((it) => ({ symbol, ...it })));
+    } catch (err) {
+      logger.warn({ err: err.message, symbol }, 'getCompanyNews failed for symbol');
+    }
+  }
+  return allNews;
+}

backend/src/markets/markets.controller.js

@@ -0,0 +1,36 @@
+/**
+ * Controladores del modulo de mercados.
+ *
+ * Responsabilidades:
+ *   - list(req, res)   → listado paginado y filtrado de mercados activos.
+ *   - getById(req, res) → detalle de un mercado por su ID nativo de Polymarket.
+ *
+ * Datos expuestos:
+ *   - id, question, category, countryCode, yesPrice, noPrice,
+ *     volumeEur, liquidityEur, status, closesAt, lastSynced.
+ *
+ * Errores:
+ *   - 404 NOT_FOUND si el mercado no existe.
+ */
+
+import { ok } from '../utils/apiResponse.js';
+import { marketsService } from './markets.service.js';
+
+export const marketsController = {
+  async list(req, res) {
+    const { limit, offset, category, status } = req.query;
+    const { data, total } = await marketsService.list({ limit, offset, category, status });
+    ok(res, data, { total, limit, offset });
+  },
+
+  async getById(req, res) {
+    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

@@ -0,0 +1,120 @@
+/**
+ * Repositorio de acceso a datos para el modelo Market.
+ *
+ * Responsabilidades:
+ *   - findMany({ limit, offset, category, status }) → listado paginado y filtrado.
+ *   - count({ category, status })                    → conteo para paginacion.
+ *   - findById(id)                                   → busqueda por ID nativo.
+ *   - upsert(market)                                 → crea o actualiza un mercado.
+ *
+ * Todas las operaciones usan Prisma ORM (queries parametrizadas, sin SQL injection).
+ * El orden por defecto es descendente por volumen (volumeEur).
+ */
+
+import { prisma } from '../utils/prisma.js';
+
+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: [{ liquidityEur: 'desc' }, { volumeEur: 'desc' }],
+      take: limit,
+      skip: offset,
+    });
+  },
+
+  count({ category, status }) {
+    const where = { status };
+    if (category) where.category = category;
+    return prisma.market.count({ where });
+  },
+
+  findById(id) {
+    return prisma.market.findUnique({ where: { id } });
+  },
+
+  upsert(market) {
+    return prisma.market.upsert({
+      where: { id: market.id },
+      update: market,
+      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

@@ -0,0 +1,22 @@
+/**
+ * Rutas REST del modulo de mercados.
+ *
+ * Endpoints (montados en /api/v1/markets):
+ *   GET /           → listado paginado/filtrado (validate listQuery en query).
+ *   GET /:id        → detalle de mercado (validate idParam en params).
+ *
+ * No requieren autenticacion (datos publicos de Polymarket).
+ */
+
+import { Router } from 'express';
+import { validate } from '../middlewares/validate.js';
+import { marketsController } from './markets.controller.js';
+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

@@ -0,0 +1,55 @@
+/**
+ * Logica de negocio del modulo de mercados.
+ *
+ * Responsabilidades:
+ *   - list(query)   → delega a marketsRepository.findMany + count para paginacion.
+ *   - getById(id)   → busca un mercado; si no existe lanza 404.
+ *
+ * Consumido por:
+ *   - markets.controller.js (API REST).
+ *   - scheduler.js (syncMarkets cada 30s).
+ *
+ * No contiene logica de scraping directa; delega a polymarket.client.js
+ * y persiste via marketsRepository.
+ */
+
+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),
+    ]);
+    return { data, total };
+  },
+
+  async getById(id) {
+    const market = await marketsRepository.findById(id);
+    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

@@ -0,0 +1,24 @@
+/**
+ * Esquemas Zod para validar inputs del modulo de mercados.
+ *
+ * Responsabilidades:
+ *   - listQuery → limit (1-100, default 20), offset, category enum, status enum.
+ *   - idParam   → string no vacio para el parametro :id.
+ *
+ * Consumido por:
+ *   - markets.routes.js → validate(listQuery, 'query') y validate(idParam, 'params').
+ */
+
+import { z } from 'zod';
+
+export const listQuery = z.object({
+  limit: z.coerce.number().int().min(1).max(200).default(60),
+  offset: z.coerce.number().int().min(0).default(0),
+  // Acepta cualquier categoria (las del DB estan en espanol y son dinamicas).
+  category: z.string().optional(),
+  status: z.enum(['active', 'closed', 'resolved']).default('active'),
+});
+
+export const idParam = z.object({
+  id: z.string().min(1),
+});

backend/src/markets/polymarket.client.js

@@ -0,0 +1,397 @@
+/**
+ * Cliente de integracion con Polymarket Gamma API.
+ *
+ * Responsabilidades:
+ *   - fetchActiveMarkets(limit) → obtiene mercados activos desde gamma-api.polymarket.com.
+ *   - mapMarket(raw)            → normaliza campos crudos a la estructura del modelo Market:
+ *       * id, question, category, countryCode
+ *       * yesPrice / noPrice (parseados desde outcomePrices JSON)
+ *       * volumeEur / liquidityEur (convertidos de USD a EUR con tasa 0.93)
+ *       * status (active | closed | resolved) derivado de flags active/closed/archived
+ *       * closesAt, lastSynced
+ *
+ * No requiere autenticacion. No usa CLOB API (solo datos publicos de mercado).
+ * Consumido por scheduler.js cada 30 segundos.
+ */
+
+import { httpGet } from '../utils/httpClient.js';
+import { logger } from '../utils/logger.js';
+
+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;
+
+/**
+ * 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';
+}
+
+function parsePrices(outcomePrices) {
+  try {
+    const arr = JSON.parse(outcomePrices);
+    return {
+      yesPrice: arr[0] != null ? parseFloat(arr[0]) : null,
+      noPrice: arr[1] != null ? parseFloat(arr[1]) : null,
+    };
+  } catch {
+    return { yesPrice: null, noPrice: null };
+  }
+}
+
+function inferCategory(question, eventTitle = '') {
+  const text = `${question} ${eventTitle}`.toLowerCase();
+
+  const rules = [
+    { keywords: ['bitcoin', 'btc', 'ethereum', 'eth', 'crypto', 'blockchain', 'solana', 'cardano', 'altcoin', 'defi', 'nft'], category: 'cripto' },
+    { keywords: ['fed', 'ecb', 'rate', 'interest', 'inflation', 'gdp', 'recession', 'economy', 'tariff', 'trade', 'dollar', 'euro', 'yen', 'bank', 'finance', 'stock market', 'sp500', 'nasdaq', 'unemployment', 'cpi', 'ppi'], category: 'economía' },
+    { keywords: ['trump', 'biden', 'election', 'president', 'democrat', 'republican', 'congress', 'senate', 'house', 'vote', 'impeach', 'nominee', 'primary', 'governor', 'mayor', 'political', 'politics', 'campaign'], category: 'política' },
+    { keywords: ['war', 'ukraine', 'russia', 'putin', 'china', 'xi', 'iran', 'israel', 'gaza', 'north korea', 'taiwan', 'invasion', 'missile', 'nuclear', 'sanctions', 'diplomatic', 'embassy', 'conflict'], category: 'geopolítica' },
+    { keywords: ['super bowl', 'world cup', 'olympics', 'nba', 'nfl', 'mlb', 'soccer', 'football', 'tennis', 'golf', 'mvp', 'championship', 'fifa', 'uefa', 'premier league', 'playoff'], category: 'deportes' },
+    { keywords: ['album', 'movie', 'oscar', 'grammy', 'emmy', 'hollywood', 'actor', 'singer', 'celebrity', 'gta', 'video game', 'song', 'chart', 'streaming', 'netflix', 'disney', 'marvel', 'rockstar'], category: 'entretenimiento' },
+    { keywords: ['ai', 'spacex', 'mars', 'rocket', 'vaccine', 'climate', 'covid', 'pandemic', 'tesla', 'elon', 'neuralink', 'fusion', 'crispr'], category: 'ciencia' },
+  ];
+
+  for (const rule of rules) {
+    if (rule.keywords.some((kw) => text.includes(kw))) {
+      return rule.category;
+    }
+  }
+
+  return 'general';
+}
+
+function inferCountryCode(question, eventTitle = '') {
+  // Envolver con espacios para evitar coincidencias parciales de substrings
+  const text = ` ${question} ${eventTitle} `.toLowerCase();
+
+  const rules = [
+    // Estados Unidos
+    { keywords: [' usa ', ' us ', ' america ', ' american ', ' trump ', ' biden ', ' clinton ', ' obama ', ' harris ', ' pence ', ' sanders ', ' warren ', ' mcconnell ', ' pelosi ', ' schumer ', ' congress ', ' senate ', ' house of representatives ', ' fed ', ' super bowl ', ' nba ', ' nfl ', ' mlb ', ' nasdaq ', ' sp500 ', ' hollywood ', ' california ', ' new york ', ' texas ', ' florida ', ' white house ', ' pentagon ', ' supreme court ', ' capitol ', ' governor of ', ' democratic nomination ', ' republican nomination ', ' presidential '], code: 'US' },
+    // Reino Unido
+    { keywords: [' uk ', ' britain ', ' british ', ' england ', ' london ', ' brexit ', ' boe ', ' pound ', ' sterling ', ' scotland ', ' wales ', ' king charles ', ' prime minister ', ' parliament ', ' westminster ', ' tory ', ' labour party '], code: 'GB' },
+    // Alemania
+    { keywords: [' germany ', ' german ', ' merkel ', ' scholz ', ' berlin ', ' bundestag ', ' deutsche '], code: 'DE' },
+    // Francia
+    { keywords: [' france ', ' french ', ' macron ', ' paris ', ' le pen ', ' élysée '], code: 'FR' },
+    // Italia
+    { keywords: [' italy ', ' italian ', ' meloni ', ' rome ', ' berlusconi '], code: 'IT' },
+    // España
+    { keywords: [' spain ', ' spanish ', ' sánchez ', ' madrid ', ' catalonia ', ' catalan '], code: 'ES' },
+    // China
+    { keywords: [' china ', ' chinese ', ' xi jinping ', ' beijing ', ' shanghai ', ' hong kong ', ' taiwan ', ' yuan ', ' alibaba ', ' byd '], code: 'CN' },
+    // Rusia
+    { keywords: [' russia ', ' russian ', ' putin ', ' moscow ', ' kremlin ', ' ruble '], code: 'RU' },
+    // India
+    { keywords: [' india ', ' indian ', ' modi ', ' mumbai ', ' delhi ', ' rupee ', ' bjp '], code: 'IN' },
+    // Brasil
+    { keywords: [' brazil ', ' brazilian ', ' brasil ', ' lula ', ' bolsonaro ', ' real '], code: 'BR' },
+    // Japón
+    { keywords: [' japan ', ' japanese ', ' tokyo ', ' boj ', ' yen ', ' nikkei ', ' suzuki '], code: 'JP' },
+    // Canadá
+    { keywords: [' canada ', ' canadian ', ' trudeau ', ' toronto ', ' loonie '], code: 'CA' },
+    // Ucrania
+    { keywords: [' ukraine ', ' ukrainian ', ' kyiv ', ' zelensky '], code: 'UA' },
+    // Israel
+    { keywords: [' israel ', ' israeli ', ' gaza ', ' netanyahu ', ' palestine ', ' palestinian ', ' hamas '], code: 'IL' },
+    // Irán
+    { keywords: [' iran ', ' iranian ', ' tehran ', ' ayatollah '], code: 'IR' },
+    // Corea
+    { keywords: [' korea ', ' north korea ', ' south korea ', ' korean ', ' seoul ', ' kim jong '], code: 'KR' },
+    // Australia
+    { keywords: [' australia ', ' australian ', ' sydney ', ' rba ', ' aud '], code: 'AU' },
+    // México
+    { keywords: [' mexico ', ' mexican ', ' peso ', ' amlo ', ' mexican president '], code: 'MX' },
+    // Turquía
+    { keywords: [' turkey ', ' turkish ', ' erdogan ', ' lira ', ' istanbul '], code: 'TR' },
+    // Arabia Saudita
+    { keywords: [' saudi ', ' saudi arabia ', ' riyadh ', ' aramco '], code: 'SA' },
+    // Sudáfrica
+    { keywords: [' south africa ', ' south african ', ' johannesburg ', ' rand '], code: 'ZA' },
+    // Argentina
+    { keywords: [' argentina ', ' argentinian ', ' milei ', ' buenos aires ', ' peso argentino '], code: 'AR' },
+    // Uzbekistán
+    { keywords: [' uzbekistan ', ' uzbek '], code: 'UZ' },
+    // Nueva Zelanda
+    { keywords: [' new zealand ', ' kiwi '], code: 'NZ' },
+    // Países Bajos
+    { keywords: [' netherlands ', ' dutch ', ' amsterdam ', ' rutte '], code: 'NL' },
+    // Polonia
+    { keywords: [' poland ', ' polish ', ' warsaw ', ' duda '], code: 'PL' },
+    // Suiza
+    { keywords: [' switzerland ', ' swiss ', ' zurich ', ' geneva ', ' franc '], code: 'CH' },
+    // Suecia
+    { keywords: [' sweden ', ' swedish ', ' stockholm '], code: 'SE' },
+    // Noruega
+    { keywords: [' norway ', ' norwegian ', ' oslo '], code: 'NO' },
+    // Dinamarca
+    { keywords: [' denmark ', ' danish ', ' copenhagen '], code: 'DK' },
+    // Finlandia
+    { keywords: [' finland ', ' finnish ', ' helsinki '], code: 'FI' },
+    // Grecia
+    { keywords: [' greece ', ' greek ', ' athens '], code: 'GR' },
+    // Portugal
+    { keywords: [' portugal ', ' portuguese ', ' lisbon '], code: 'PT' },
+    // Bélgica
+    { keywords: [' belgium ', ' belgian ', ' brussels '], code: 'BE' },
+    // Austria
+    { keywords: [' austria ', ' austrian ', ' vienna '], code: 'AT' },
+    // Irlanda
+    { keywords: [' ireland ', ' irish ', ' dublin '], code: 'IE' },
+    // Pakistán
+    { keywords: [' pakistan ', ' pakistani ', ' islamabad '], code: 'PK' },
+    // Bangladés
+    { keywords: [' bangladesh ', ' bangladeshi ', ' dhaka '], code: 'BD' },
+    // Indonesia
+    { keywords: [' indonesia ', ' indonesian ', ' jakarta '], code: 'ID' },
+    // Filipinas
+    { keywords: [' philippines ', ' filipino ', ' manila '], code: 'PH' },
+    // Vietnam
+    { keywords: [' vietnam ', ' vietnamese ', ' hanoi '], code: 'VN' },
+    // Tailandia
+    { keywords: [' thailand ', ' thai ', ' bangkok '], code: 'TH' },
+    // Malasia
+    { keywords: [' malaysia ', ' malaysian ', ' kuala lumpur '], code: 'MY' },
+    // Singapur
+    { keywords: [' singapore ', ' singaporean '], code: 'SG' },
+    // Colombia
+    { keywords: [' colombia ', ' colombian ', ' bogotá '], code: 'CO' },
+    // Chile
+    { keywords: [' chile ', ' chilean ', ' santiago '], code: 'CL' },
+    // Perú
+    { keywords: [' peru ', ' peruvian ', ' lima '], code: 'PE' },
+    // Venezuela
+    { keywords: [' venezuela ', ' venezuelan ', ' caracas ', ' maduro '], code: 'VE' },
+    // Ecuador
+    { keywords: [' ecuador ', ' ecuadorian ', ' quito '], code: 'EC' },
+    // Nigeria
+    { keywords: [' nigeria ', ' nigerian ', ' lagos ', ' abuja '], code: 'NG' },
+    // Egipto
+    { keywords: [' egypt ', ' egyptian ', ' cairo '], code: 'EG' },
+    // Etiopía
+    { keywords: [' ethiopia ', ' ethiopian ', ' addis ababa '], code: 'ET' },
+    // Kenia
+    { keywords: [' kenya ', ' kenyan ', ' nairobi '], code: 'KE' },
+    // Cuba
+    { keywords: [' cuba ', ' cuban ', ' havana '], code: 'CU' },
+    // República Dominicana
+    { keywords: [' dominican republic ', ' dominican '], code: 'DO' },
+    // Curazao
+    { keywords: [' curaçao ', ' curacao '], code: 'CW' },
+  ];
+
+  for (const rule of rules) {
+    if (rule.keywords.some((kw) => text.includes(kw))) {
+      return rule.code;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 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 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,
+    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(),
+  };
+}
+
+/**
+ * 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/positions/kelly.js

@@ -0,0 +1,95 @@
+/**
+ * Criterio de Kelly para sizing de posiciones, limitado al 25%.
+ *
+ * Formula:
+ *   odds = (1 / price) - 1
+ *   k = (odds * pWin - pLose) / odds
+ *   return min(max(k, 0), 0.25)
+ *
+ * Parametros:
+ *   - price : precio actual del outcome (0 < price < 1).
+ *   - pWin  : probabilidad de ganar (usamos confidence de la senal IA).
+ *
+ * Devuelve:
+ *   Fraccion del capital virtual recomendada (0.0 a 0.25).
+ */
+export function kellyFraction(price, pWin) {
+  if (!price || price <= 0 || price >= 1 || !pWin) return 0;
+  const pLose = 1 - pWin;
+  const odds = 1 / price - 1;
+  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.repository.js

@@ -0,0 +1,43 @@
+/**
+ * Repositorio de acceso a datos para el modelo Position.
+ *
+ * Responsabilidades:
+ *   - create(data)       → inserta una nueva posicion virtual.
+ *   - findByUser(userId, status) → lista posiciones del usuario con datos del mercado.
+ *   - findByIdAndUser(id, userId) → busca posicion propia del usuario.
+ *   - findAllOpen()      → todas las posiciones abiertas (para recalcular P&L).
+ *   - update(id, data)   → actualiza precio, P&L, estado, etc.
+ *
+ * Todas las operaciones usan Prisma ORM.
+ */
+
+import { prisma } from '../utils/prisma.js';
+
+export const positionsRepository = {
+  create(data) {
+    return prisma.position.create({ data });
+  },
+
+  findByUser(userId, status) {
+    return prisma.position.findMany({
+      where: { userId, ...(status ? { status } : {}) },
+      include: { market: { select: { id: true, question: true, yesPrice: true, noPrice: true, status: true } } },
+      orderBy: { openedAt: 'desc' },
+    });
+  },
+
+  findByIdAndUser(id, userId) {
+    return prisma.position.findFirst({ where: { id, userId } });
+  },
+
+  findAllOpen() {
+    return prisma.position.findMany({
+      where: { status: 'open' },
+      include: { market: { select: { yesPrice: true, noPrice: true } } },
+    });
+  },
+
+  update(id, data) {
+    return prisma.position.update({ where: { id }, data });
+  },
+};

backend/src/positions/positions.routes.js

@@ -0,0 +1,29 @@
+/**
+ * Rutas REST del modulo de posiciones (simulador virtual).
+ *
+ * Endpoints (montados en /api/v1/positions):
+ *   POST /       → abrir posicion (validate openBody).
+ *   GET /        → listar posiciones (validate listQuery en query).
+ *   DELETE /:id  → cerrar posicion (validate idParam en params).
+ *
+ * Todas las rutas requieren autenticacion JWT (router.use(requireAuth)).
+ */
+
+import { Router } from 'express';
+import { validate } from '../middlewares/validate.js';
+import { requireAuth } from '../middlewares/requireAuth.js';
+import { positionsController } from './positions.controller.js';
+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);
+router.get('/', validate(listQuery, 'query'), positionsController.list);
+router.delete('/:id', validate(idParam, 'params'), positionsController.close);
+
+export default router;

backend/src/positions/positions.service.js

@@ -0,0 +1,119 @@
+/**
+ * Logica de negocio del modulo de posiciones (simulador virtual).
+ *
+ * Responsabilidades:
+ *   - open(userId, { marketId, outcome, amountEur })
+ *     → valida que el mercado exista y este activo, obtiene precio de entrada,
+ *       calcula fraccion de Kelly y crea la posicion.
+ *   - list(userId, status) → devuelve posiciones del usuario.
+ *   - close(id, userId)    → calcula P&L final con el precio actual y marca como cerrada.
+ *   - updateAllPnL()       → recalcula P&L de todas las posiciones abiertas (scheduler).
+ *
+ * Calculos:
+ *   - P&L = amountEur * (currentPrice / entryPrice - 1).
+ *   - Kelly = (odds * pWin - pLose) / odds, capped al 25%.
+ *
+ * Consumido por:
+ *   - positions.controller.js (API REST).
+ *   - scheduler.js (updatePositionsPnL cada 30s).
+ */
+
+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, suggestSize } from './kelly.js';
+
+function currentPriceForOutcome(market, outcome) {
+  return outcome === 'YES' ? market.yesPrice : market.noPrice;
+}
+
+function calcPnl(amountEur, entryPrice, currentPrice) {
+  if (!currentPrice || !entryPrice) return 0;
+  return amountEur * (currentPrice / entryPrice - 1);
+}
+
+export const positionsService = {
+  async open(userId, { marketId, outcome, amountEur }) {
+    const market = await marketsRepository.findById(marketId);
+    if (!market) throw new HttpError(404, 'NOT_FOUND', 'Market not found');
+    if (market.status !== 'active') throw new HttpError(409, 'MARKET_CLOSED', 'Market is not active');
+
+    const entryPrice = currentPriceForOutcome(market, outcome);
+    if (!entryPrice) throw new HttpError(409, 'NO_PRICE', 'Market price unavailable');
+
+    const latestSignal = await signalsRepository.findLatestByMarket(marketId);
+    const confidence = latestSignal?.confidence ?? 0.5;
+    const fraction = kellyFraction(entryPrice, confidence);
+
+    return positionsRepository.create({
+      userId,
+      marketId,
+      outcome,
+      amountEur,
+      entryPrice,
+      currentPrice: entryPrice,
+      pnl: 0,
+      kellyFraction: fraction,
+      status: 'open',
+    });
+  },
+
+  list(userId, status) {
+    return positionsRepository.findByUser(userId, status);
+  },
+
+  async close(id, userId) {
+    const position = await positionsRepository.findByIdAndUser(id, userId);
+    if (!position) throw new HttpError(404, 'NOT_FOUND', 'Position not found');
+    if (position.status === 'closed') throw new HttpError(409, 'ALREADY_CLOSED', 'Position already closed');
+
+    const market = await marketsRepository.findById(position.marketId);
+    const currentPrice = market ? currentPriceForOutcome(market, position.outcome) : position.entryPrice;
+    const finalPnl = calcPnl(position.amountEur, position.entryPrice, currentPrice);
+
+    return positionsRepository.update(id, {
+      status: 'closed',
+      currentPrice,
+      pnl: finalPnl,
+      closedAt: new Date(),
+    });
+  },
+
+  /**
+   * 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(
+      open.map((pos) => {
+        const currentPrice = currentPriceForOutcome(pos.market, pos.outcome);
+        if (!currentPrice) return Promise.resolve();
+        return positionsRepository.update(pos.id, {
+          currentPrice,
+          pnl: calcPnl(pos.amountEur, pos.entryPrice, currentPrice),
+        });
+      }),
+    );
+  },
+};

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,
+  };
+}

backend/src/utils/httpClient.js

@@ -0,0 +1,88 @@
+/**
+ * Cliente HTTP reutilizable con retry y timeout.
+ *
+ * Responsabilidades:
+ *   - Realizar peticiones GET y POST usando fetch nativo de Node.js.
+ *   - Aplicar timeout via AbortController.
+ *   - Reintentar automaticamente ante errores de red o HTTP 429/5xx.
+ *   - Backoff exponencial con tope de 30s.
+ *   - Inyectar User-Agent: PolySignal/1.0 en todas las peticiones.
+ *
+ * Uso:
+ *   const data = await httpGet(url, { headers, timeout, retries });
+ *   const data = await httpPost(url, body, { headers, timeout, retries });
+ */
+
+import { logger } from './logger.js';
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_RETRIES = 3;
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+
+function backoff(attempt) {
+  return Math.min(1_000 * 2 ** attempt, 30_000);
+}
+
+async function request(url, init = {}, { timeout = DEFAULT_TIMEOUT_MS, retries = DEFAULT_RETRIES } = {}) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const res = await fetch(url, {
+        ...init,
+        headers: { 'User-Agent': 'PolySignal/1.0', ...init.headers },
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (RETRYABLE_STATUSES.has(res.status) && attempt < retries) {
+        const wait = backoff(attempt);
+        logger.warn({ url, status: res.status, attempt, wait }, 'retrying request');
+        await new Promise((r) => setTimeout(r, wait));
+        continue;
+      }
+
+      const text = await res.text();
+      const data = text ? JSON.parse(text) : null;
+
+      if (!res.ok) {
+        const err = Object.assign(new Error(`HTTP ${res.status} — ${url}`), {
+          status: res.status,
+          body: data,
+        });
+        throw err;
+      }
+
+      return data;
+    } catch (err) {
+      clearTimeout(timeoutId);
+
+      if (err.name === 'AbortError') {
+        throw Object.assign(new Error(`Timeout after ${timeout}ms — ${url}`), { code: 'TIMEOUT' });
+      }
+
+      // network error (no HTTP status) → retry
+      if (!err.status && attempt < retries) {
+        const wait = backoff(attempt);
+        logger.warn({ url, err: err.message, attempt, wait }, 'network error, retrying');
+        await new Promise((r) => setTimeout(r, wait));
+        continue;
+      }
+
+      logger.error({ url, err: err.message }, 'request failed');
+      throw err;
+    }
+  }
+}
+
+export const httpGet = (url, { headers, ...opts } = {}) =>
+  request(url, { method: 'GET', headers }, opts);
+
+export const httpPost = (url, body, { headers, ...opts } = {}) =>
+  request(
+    url,
+    { method: 'POST', headers: { 'Content-Type': 'application/json', ...headers }, body: JSON.stringify(body) },
+    opts,
+  );

backend/src/utils/prisma.js

@@ -0,0 +1,26 @@
+/**
+ * Instancia singleton de PrismaClient.
+ *
+ * Responsabilidades:
+ *   - Gestionar la conexion a SQLite (desarrollo) o PostgreSQL (produccion).
+ *   - Reutilizar la misma instancia en hot-reload (guardada en globalThis).
+ *   - Loguear solo warns y errores para no saturar la salida.
+ *
+ * Relaciones:
+ *   - Todos los repositories importan este prisma para ejecutar queries.
+ *   - schema.prisma define los modelos: User, Market, AISignal, Position, Watchlist, Alert.
+ */
+
+import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis;
+
+export const prisma =
+  globalForPrisma.__prisma__ ??
+  new PrismaClient({
+    log: ['warn', 'error'],
+  });
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.__prisma__ = prisma;
+}