🚀 Fusion: NexusCRM + Lead Gen Pro (100% Cloud Docker)

.dockerignore

@@ -0,0 +1,12 @@
+# Ignore local development artifacts
+**/__pycache__
+**/*.pyc
+**/venv
+**/*.db
+**/*.bat
+**/*.log
+**/*.zip
+**/node_modules
+.git
+.gitignore
+.dockerignore

Dockerfile

@@ -0,0 +1,66 @@
+# NexusCRM + Lead Gen Pro: Unified Cloud Dockerfile
+# Optimized for Hugging Face Spaces (Docker SDK)
+
+# Using Python 3.10 slim for a balance of speed and stability
+FROM python:3.10-slim
+
+# Prevent Python from writing .pyc files and enable unbuffered logging
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    # Hugging Face Spaces port is 7860
+    PORT=7860 \
+    # Playwright headless requirements
+    PLAYWRIGHT_BROWSERS_PATH=/app/pw-browsers
+
+# Install system dependencies required for Chromium and Playwright
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    wget \
+    gnupg \
+    libnss3 \
+    libnspr4 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdrm2 \
+    libxkbcommon0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxext6 \
+    libxfixes3 \
+    librandr2 \
+    libgbm1 \
+    libpango-1.0-0 \
+    libcairo2 \
+    libasound2 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python dependencies (including apify-client for the scraping engine)
+RUN pip install --no-cache-dir \
+    flask \
+    flask-cors \
+    playwright \
+    supabase \
+    pandas \
+    python-dotenv \
+    gunicorn \
+    apify-client
+
+# Install Playwright and the Chromium browser
+RUN playwright install chromium
+RUN playwright install-deps chromium
+
+# Preparation of the working environment
+# The entire folder (app.py, static/, lead_gen_pro/) is copied to /app
+COPY . .
+
+# Create a data directory for temporary SQLite files if it doesn't exist
+RUN mkdir -p /app/lead_gen_pro/data && chmod 777 /app/lead_gen_pro/data
+
+# Expose the HF port
+EXPOSE 7860
+
+# Use gunicorn for a production-ready server in the cloud
+# We bind to 0.0.0.0 because it's a container
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "8", "--timeout", "0", "app:app"]

README.md

@@ -1,12 +1,13 @@
 ---
-title: Nexus CRM
-emoji: 📊
+title: NexusCRM
+emoji: 💼
 colorFrom: blue
-colorTo: purple
-sdk: static
+colorTo: indigo
+sdk: docker
+sdk_version: 4.0.0
 app_port: 7860
 ---
 
-# Nexus CRM
+# NexusCRM
 
-CRM + Lead Gen SaaS - Gestiona clientes y leads en la nube.
+SaaS CRM System with Supabase backend

app.py

@@ -0,0 +1,194 @@
+import os
+import sys
+import subprocess
+import threading
+import queue
+import time
+from flask import Flask, send_from_directory, request, jsonify, Response
+from flask_cors import CORS
+from dotenv import load_dotenv
+
+# Load environment variables (from Hugging Face Secrets)
+load_dotenv()
+
+# Ensure lead_gen_pro is in the path so we can import its modules
+sys.path.append(os.path.join(os.getcwd(), 'lead_gen_pro'))
+
+app = Flask(__name__, static_folder='static')
+CORS(app)
+
+# --- Configuration ---
+PORT = int(os.environ.get("PORT", 7860))
+BASE_DIR = os.path.join(os.getcwd(), 'lead_gen_pro')
+# In Docker, we use the local path for the temporary DB
+DB_PATH = os.path.join(BASE_DIR, "leads_doe.db")
+MAIN_PRO = os.path.join(BASE_DIR, "main_pro.py")
+
+# Log queue for SSE (Server-Sent Events)
+log_queue = queue.Queue()
+active_process = None
+process_lock = threading.Lock()
+
+# --- Unified UI Serving ---
+
+@app.route("/")
+def index():
+    """Serve the NexusCRM frontend."""
+    return send_from_directory(app.static_folder, "index.html")
+
+@app.route("/<path:path>")
+def static_proxy(path):
+    """Serve other static files if any."""
+    return send_from_directory(app.static_folder, path)
+
+# --- Backend API Endpoints ---
+
+@app.route("/api/health")
+def health():
+    """Verify the cloud server is active."""
+    return jsonify({
+        "status": "online",
+        "environment": "Hugging Face Cloud",
+        "db_access": os.path.exists(DB_PATH)
+    })
+
+@app.route("/api/scrape", methods=["POST"])
+def scrape():
+    """Bridge to the Lead Gen Pro scraping engine."""
+    global active_process
+    
+    with process_lock:
+        if active_process and active_process.poll() is None:
+            return jsonify({"error": "A scraping process is already running in the cloud."}), 409
+
+    data = request.get_json(force=True) or {}
+    
+    # We use 'python' because it's the environment in the Docker container
+    cmd = [
+        "python", MAIN_PRO,
+        "--pipeline",
+        "--niche", data.get("niche", "Real Estate"),
+        "--limit", str(data.get("limit", 20)),
+        "--type", data.get("lead_type", "both")
+    ]
+    
+    # Geographic settings
+    if data.get("country"): cmd += ["--country", data["country"]]
+    if data.get("state"):   cmd += ["--state",   data["state"]]
+    if data.get("city"):    cmd += ["--city",     data["city"]]
+
+    def _run_worker():
+        global active_process
+        log_queue.put("🚀 [CLOUD] Iniciando motor de scraping en Hugging Face...\n")
+        
+        # Start the scraping process
+        proc = subprocess.Popen(
+            cmd, 
+            cwd=BASE_DIR,
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env={**os.environ, "PYTHONUNBUFFERED": "1"}
+        )
+        
+        with process_lock:
+            active_process = proc
+
+        # Stream logs line by line
+        for line in proc.stdout:
+            log_queue.put(line)
+        
+        proc.wait()
+        log_queue.put(f"\n✅ [CLOUD] Proceso finalizado (Código: {proc.returncode})\n")
+        
+        # Automatic Cloud Sync (Supabase)
+        try:
+            log_queue.put("♻️ [CLOUD] Sincronizando resultados con Supabase Cloud...\n")
+            # Dynamic import to ensure it uses the cloud environment
+            from l3_execution.supabase_sync import sync_all_leads_to_supabase
+            stats = sync_all_leads_to_supabase()
+            log_queue.put(f"📊 [SYNC] Sincronización exitosa: {stats}\n")
+        except Exception as e:
+            log_queue.put(f"❌ [SYNC-ERROR] Error en sincronización cloud: {str(e)}\n")
+            
+        log_queue.put("[END]")
+
+    # Run in background to not block the request
+    threading.Thread(target=_run_worker, daemon=True).start()
+    return jsonify({"status": "launched", "location": "Hugging Face Space"})
+
+@app.route("/api/stream")
+def stream():
+    """SSE endpoint for real-time logs in the CRM UI."""
+    def generate():
+        yield "data: [CONECTADO] Servidor Hugging Face listo...\n\n"
+        while True:
+            try:
+                line = log_queue.get(timeout=60)
+                if line == "[END]":
+                    yield "data: [END]\n\n"
+                    break
+                yield f"data: {line.rstrip()}\n\n"
+            except queue.Empty:
+                yield "data: [PING]\n\n"
+    
+    return Response(generate(), mimetype="text/event-stream")
+
+@app.route("/api/sync", methods=["POST"])
+def manual_sync():
+    """Force manual sync to Supabase from the cloud."""
+    try:
+        from l3_execution.supabase_sync import sync_all_leads_to_supabase
+        res = sync_all_leads_to_supabase()
+        return jsonify({"status": "success", "data": res})
+    except Exception as e:
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route("/api/stats")
+def stats():
+    """Get lead generation statistics from the local container DB."""
+    import sqlite3
+    try:
+        if not os.path.exists(DB_PATH):
+            return jsonify({
+                "total": 0,
+                "leads_30d": 0,
+                "pending_whatsapp": 0,
+                "by_niche": {}
+            })
+            
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        cur = conn.cursor()
+        
+        # Total
+        cur.execute("SELECT COUNT(*) FROM leads")
+        total = cur.fetchone()[0]
+        
+        # Last 30 days
+        cur.execute("SELECT COUNT(*) FROM leads WHERE created_at > date('now', '-30 days')")
+        total_30d = cur.fetchone()[0]
+        
+        # Pending WhatsApp
+        cur.execute("SELECT COUNT(*) FROM leads WHERE (whatsapp_enviado IS NULL OR whatsapp_enviado = 0) AND (telefono IS NOT NULL OR telefono_formateado IS NOT NULL)")
+        pending_wa = cur.fetchone()[0]
+        
+        # By niche
+        cur.execute("SELECT nicho, COUNT(*) as count FROM leads GROUP BY nicho ORDER BY count DESC LIMIT 5")
+        by_niche = {row['nicho']: row['count'] for row in cur.fetchall() if row['nicho']}
+        
+        conn.close()
+        
+        return jsonify({
+            "total": total,
+            "leads_30d": total_30d,
+            "pending_whatsapp": pending_wa,
+            "by_niche": by_niche
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == "__main__":
+    # Local fallback for testing, but Docker uses gunicorn
+    app.run(host="0.0.0.0", port=PORT)

lead_gen_pro/config.json

@@ -0,0 +1,46 @@
+{
+    "apify_token": "apify_api_J3amq3BFZwtBTddaYQn3PkJxLjeZno0geYY7",
+    "serpapi_key": "YOUR_SERPAPI_KEY",
+    "sender_name": "NexusCRM Butler",
+    "niches": {
+        "real_estate": {
+            "search_queries": [
+                "real estate agent in {city}",
+                "realtor in {city}",
+                "luxury homes in {city}",
+                "property management {city}"
+            ],
+            "templates": {
+                "email": {
+                    "subject": "Colaboración para {name} en {city}",
+                    "body": "Hola {name},\n\nVi tu excelente perfil inmobiliario en {city}. Estoy ayudando a realtors a automatizar su captación de leads.\n\n¿Te interesaría una breve llamada?\n\nSaludos,\n{sender_name}"
+                },
+                "whatsapp": "¡Hola {name}! Vi tu trabajo en {city}. Tengo una propuesta para automatizar tu prospección inmobiliaria. ¿Hablamos?"
+            }
+        },
+        "insurance": {
+            "search_queries": [
+                "insurance agent in {city}",
+                "seguros en {city}",
+                "broker de seguros {city}"
+            ],
+            "templates": {
+                "email": {
+                    "subject": "Idea for your insurance business in {city}",
+                    "body": "Hi {name},\n\nI noticed your insurance agency in {city}. We help brokers get more leads. Are you interested?\n\nBest,\n{sender_name}"
+                },
+                "whatsapp": "¡Hola {name}! Noté tu éxito en el sector seguros en {city}. Tengo una propuesta para automatizar tu prospección. ¿Hablamos?"
+            }
+        }
+    },
+    "automation_rules": [
+        {
+            "if": {"field": "quality_score", "operator": ">=", "value": 8},
+            "then": {"type": "mark_priority", "value": 3}
+        },
+        {
+            "if": {"field": "niche", "operator": "==", "value": "real_estate"},
+            "then": {"type": "notify", "message": "New Real Estate lead detected!"}
+        }
+    ]
+}

lead_gen_pro/database.py

@@ -0,0 +1,268 @@
+"""
+Lead Generation Database Module
+================================
+Manages SQLite database for storing and tracking leads.
+"""
+
+import sqlite3
+import os
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+DB_PATH = os.path.join(os.path.dirname(__file__), "leads.db")
+
+
+def get_connection() -> sqlite3.Connection:
+    """Get a database connection with row factory enabled."""
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_db() -> None:
+    """Initialize the database with required tables."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS leads (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            phone TEXT,
+            email TEXT,
+            address TEXT,
+            website TEXT,
+            rating REAL,
+            reviews_count INTEGER,
+            source TEXT DEFAULT 'google_maps',
+            niche TEXT NOT NULL,
+            country TEXT NOT NULL,
+            city TEXT,
+            status TEXT DEFAULT 'new',
+            whatsapp_sent BOOLEAN DEFAULT 0,
+            instagram_sent BOOLEAN DEFAULT 0,
+            replied BOOLEAN DEFAULT 0,
+            notes TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS outreach_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            lead_id INTEGER NOT NULL,
+            channel TEXT NOT NULL,
+            message_template TEXT,
+            sent_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            response TEXT,
+            FOREIGN KEY (lead_id) REFERENCES leads(id)
+        )
+    """)
+    
+    cursor.execute("""
+        CREATE INDEX IF NOT EXISTS idx_leads_status ON leads(status)
+    """)
+    cursor.execute("""
+        CREATE INDEX IF NOT EXISTS idx_leads_niche ON leads(niche)
+    """)
+    cursor.execute("""
+        CREATE INDEX IF NOT EXISTS idx_leads_country ON leads(country)
+    """)
+    
+    conn.commit()
+    conn.close()
+    print(f"[OK] Base de datos inicializada en: {DB_PATH}")
+
+
+def add_lead(lead_data: Dict[str, Any]) -> int:
+    """
+    Add a new lead to the database.
+    
+    Args:
+        lead_data: Dictionary with lead information.
+        
+    Returns:
+        The ID of the inserted lead.
+    """
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        INSERT INTO leads (name, phone, email, address, website, rating, 
+                          reviews_count, source, niche, country, city, notes)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (
+        lead_data.get("name"),
+        lead_data.get("phone"),
+        lead_data.get("email"),
+        lead_data.get("address"),
+        lead_data.get("website"),
+        lead_data.get("rating"),
+        lead_data.get("reviews_count"),
+        lead_data.get("source", "google_maps"),
+        lead_data.get("niche"),
+        lead_data.get("country"),
+        lead_data.get("city"),
+        lead_data.get("notes")
+    ))
+    
+    lead_id = cursor.lastrowid
+    conn.commit()
+    conn.close()
+    return lead_id
+
+
+def get_leads(
+    niche: Optional[str] = None,
+    country: Optional[str] = None,
+    status: Optional[str] = None,
+    limit: int = 100
+) -> List[Dict[str, Any]]:
+    """
+    Retrieve leads with optional filters.
+    
+    Args:
+        niche: Filter by niche (real_estate, insurance)
+        country: Filter by country (usa, venezuela)
+        status: Filter by status (new, contacted, replied, converted)
+        limit: Maximum number of results
+        
+    Returns:
+        List of lead dictionaries.
+    """
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    query = "SELECT * FROM leads WHERE 1=1"
+    params = []
+    
+    if niche:
+        query += " AND niche = ?"
+        params.append(niche)
+    if country:
+        query += " AND country = ?"
+        params.append(country)
+    if status:
+        query += " AND status = ?"
+        params.append(status)
+    
+    query += " ORDER BY created_at DESC LIMIT ?"
+    params.append(limit)
+    
+    cursor.execute(query, params)
+    rows = cursor.fetchall()
+    conn.close()
+    
+    return [dict(row) for row in rows]
+
+
+def update_lead_status(lead_id: int, status: str, notes: Optional[str] = None) -> None:
+    """Update the status of a lead."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    if notes:
+        cursor.execute("""
+            UPDATE leads 
+            SET status = ?, notes = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        """, (status, notes, lead_id))
+    else:
+        cursor.execute("""
+            UPDATE leads 
+            SET status = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        """, (status, lead_id))
+    
+    conn.commit()
+    conn.close()
+
+
+def mark_outreach_sent(lead_id: int, channel: str, template: str) -> None:
+    """Mark that outreach was sent to a lead and log it."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    # Update lead flags
+    if channel == "whatsapp":
+        cursor.execute("UPDATE leads SET whatsapp_sent = 1, status = 'contacted' WHERE id = ?", (lead_id,))
+    elif channel == "instagram":
+        cursor.execute("UPDATE leads SET instagram_sent = 1, status = 'contacted' WHERE id = ?", (lead_id,))
+    
+    # Log the outreach
+    cursor.execute("""
+        INSERT INTO outreach_log (lead_id, channel, message_template)
+        VALUES (?, ?, ?)
+    """, (lead_id, channel, template))
+    
+    conn.commit()
+    conn.close()
+
+
+def get_pending_outreach(channel: str, niche: Optional[str] = None, limit: int = 10) -> List[Dict[str, Any]]:
+    """Get leads that haven't been contacted yet via a specific channel."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    query = "SELECT * FROM leads WHERE status = 'new'"
+    params = []
+    
+    if channel == "whatsapp":
+        query += " AND whatsapp_sent = 0 AND phone IS NOT NULL"
+    elif channel == "instagram":
+        query += " AND instagram_sent = 0"
+    
+    if niche:
+        query += " AND niche = ?"
+        params.append(niche)
+    
+    query += " LIMIT ?"
+    params.append(limit)
+    
+    cursor.execute(query, params)
+    rows = cursor.fetchall()
+    conn.close()
+    
+    return [dict(row) for row in rows]
+
+
+def get_stats() -> Dict[str, Any]:
+    """Get statistics about the leads database."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    stats = {}
+    
+    cursor.execute("SELECT COUNT(*) FROM leads")
+    stats["total_leads"] = cursor.fetchone()[0]
+    
+    cursor.execute("SELECT niche, COUNT(*) FROM leads GROUP BY niche")
+    stats["by_niche"] = dict(cursor.fetchall())
+    
+    cursor.execute("SELECT country, COUNT(*) FROM leads GROUP BY country")
+    stats["by_country"] = dict(cursor.fetchall())
+    
+    cursor.execute("SELECT status, COUNT(*) FROM leads GROUP BY status")
+    stats["by_status"] = dict(cursor.fetchall())
+    
+    cursor.execute("SELECT COUNT(*) FROM leads WHERE whatsapp_sent = 1")
+    stats["whatsapp_sent"] = cursor.fetchone()[0]
+    
+    cursor.execute("SELECT COUNT(*) FROM leads WHERE instagram_sent = 1")
+    stats["instagram_sent"] = cursor.fetchone()[0]
+    
+    conn.close()
+    return stats
+
+
+if __name__ == "__main__":
+    # Initialize the database when run directly
+    init_db()
+    
+    # Show current stats
+    stats = get_stats()
+    print(f"\n[ESTADISTICAS] Estadisticas de la Base de Datos:")
+    print(f"   Total leads: {stats['total_leads']}")
+    print(f"   Por nicho: {stats['by_niche']}")
+    print(f"   Por país: {stats['by_country']}")

lead_gen_pro/l1_directive/outreach_sop.md

@@ -0,0 +1,79 @@
+# L1 Directive: Outreach SOP
+# ===========================
+# Este documento define las reglas para mensajes de WhatsApp y Email.
+
+## Objetivo
+Contactar leads de manera profesional y personalizada para generar oportunidades de negocio.
+
+## Canales
+1. **WhatsApp Business** - Para contacto directo e inmediato
+2. **Email (Instantly.ai)** - Para seguimiento profesional
+
+## Reglas Generales
+- Nunca enviar más de 20 mensajes por hora
+- Esperar mínimo 30 segundos entre cada mensaje
+- Horario de envío: 9am-6pm zona del destinatario
+- Personalizar SIEMPRE con nombre y ciudad
+
+---
+
+## Templates de WhatsApp
+
+### Real Estate - USA
+```
+Hi {name}! I came across your profile while researching top agents in {city}. 
+I help real estate professionals automate their lead generation.
+Would you be interested in a quick 5-min chat?
+```
+
+### Real Estate - Venezuela
+```
+¡Hola {name}! Vi tu perfil mientras buscaba los mejores agentes en {city}.
+Ayudo a profesionales inmobiliarios a automatizar su captación de clientes.
+¿Te interesaría una llamada rápida de 5 minutos?
+```
+
+### Insurance - USA
+```
+Hi {name}! I noticed your insurance agency in {city} has great reviews.
+I work with insurance professionals to help them get more qualified leads.
+Would you be open to a brief conversation?
+```
+
+### Insurance - Venezuela
+```
+¡Hola {name}! Noté que tu agencia de seguros en {city} tiene excelentes reseñas.
+Trabajo con profesionales de seguros para ayudarles a conseguir más clientes.
+¿Estarías abierto a una breve conversación?
+```
+
+---
+
+## Templates de Email
+
+### Subject Lines
+- "Quick question about {city} real estate"
+- "Idea for your {niche} business"
+- "Saw your great reviews in {city}"
+
+### Email Body (Real Estate)
+```
+Hi {name},
+
+I came across your profile while researching top real estate professionals in {city}.
+
+I help agents like yourself automate their lead generation process, 
+often resulting in 2-3x more qualified leads without extra effort.
+
+Would you be open to a 10-minute call this week to explore if this could work for you?
+
+Best regards,
+[Your Name]
+```
+
+---
+
+## Seguimiento
+- Si no hay respuesta en 48h, enviar follow-up por el otro canal
+- Máximo 3 intentos de contacto por lead
+- Marcar lead como "no interesado" después de 3 intentos sin respuesta

lead_gen_pro/l1_directive/scraping_sop.md

@@ -0,0 +1,46 @@
+# L1 Directive: Scraping SOP
+# ===========================
+# Este documento define las reglas para el agente de scraping.
+
+## Objetivo
+Extraer leads de negocios (bienes raíces y seguros) de Google Maps y LinkedIn usando Apify.
+
+## Parámetros de Entrada
+- **niche**: `real_estate` | `insurance`
+- **country**: `usa` | `venezuela`
+- **cities**: Lista de ciudades objetivo
+- **limit**: Máximo de leads por ciudad (default: 20)
+
+## Queries Predefinidas
+
+### Real Estate
+| País | Queries |
+|------|---------|
+| USA | "real estate agent", "realtor", "property broker" |
+| Venezuela | "inmobiliaria", "agente inmobiliario", "bienes raices" |
+
+### Insurance
+| País | Queries |
+|------|---------|
+| USA | "insurance agent", "insurance broker", "life insurance" |
+| Venezuela | "corredor de seguros", "agente de seguros" |
+
+## Reglas de Ejecución
+1. Ejecutar scraping en horario laboral (9am-6pm zona objetivo)
+2. Máximo 100 leads por ejecución para evitar rate limits
+3. Esperar 5 segundos entre cada request a Apify
+4. Guardar todos los leads en database antes de siguiente paso
+
+## Campos Requeridos por Lead
+- `name` (obligatorio)
+- `phone` (obligatorio para WhatsApp)
+- `email` (deseable para Instantly)
+- `address`
+- `website`
+- `rating`
+- `reviews_count`
+
+## Errores y Retry
+- Si Apify retorna error, esperar 60 segundos y reintentar
+- Máximo 3 reintentos por query
+- Loggear todos los errores en `logs/scraping.log`

lead_gen_pro/l2_orchestration/__init__.py

@@ -0,0 +1 @@
+# __init__.py for l2_orchestration module

lead_gen_pro/l2_orchestration/orchestrator.py

@@ -0,0 +1,319 @@
+"""
+L2 Orchestration: Main Workflow Orchestrator
+=============================================
+Orquestador principal que coordina todo el flujo de lead generation.
+Implementa la capa L2 del framework DOE (lógica sin código de ejecución).
+"""
+
+import os
+import sys
+import json
+import time
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+# Add parent to path
+sys.path.insert(0, os.path.dirname(__file__))
+
+# Import L3 Execution modules
+from l3_execution.database_doe import init_db, add_lead, get_leads, get_pending_outreach, mark_outreach, get_stats
+from l3_execution.apify_scraper import scrape_leads
+from l3_execution.enrichment import enrich_leads
+from l3_execution.instantly_sender import batch_send_emails, demo_email_preview
+
+# Import old WhatsApp module for compatibility
+sys.path.insert(0, os.path.join(os.path.dirname(__file__)))
+from whatsapp_sender import batch_generate_links
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration."""
+    config_path = os.path.join(os.path.dirname(__file__), "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            return json.load(f)
+    return {}
+
+
+def print_header(title: str):
+    """Print formatted header."""
+    print(f"\n{'='*60}")
+    print(f"  {title}")
+    print(f"{'='*60}\n")
+
+
+def run_full_pipeline(
+    niche: str = "real_estate",
+    country: str = "usa",
+    location: Optional[str] = None,
+    limit_per_city: int = 10,
+    demo: bool = False
+) -> Dict[str, Any]:
+    """
+    Execute the complete lead generation pipeline:
+    1. Scrape leads
+    2. Enrich data
+    3. Store in database
+    4. Generate outreach
+    
+    Args:
+        niche: 'real_estate' or 'insurance'
+        country: 'usa' or 'venezuela'
+        limit_per_city: Leads per city
+        demo: Use demo mode
+        
+    Returns:
+        Pipeline results dictionary.
+    """
+    config = load_config()
+    results = {"steps": [], "stats": {}}
+    
+    print_header(f"🚀 PIPELINE DOE: {niche.upper()} / {country.upper()}")
+    
+    # Step 1: Scraping
+    print("📍 PASO 1: Scraping de Google Maps")
+    print("-" * 40)
+    
+    leads = scrape_leads(
+        niche=niche,
+        country=country,
+        location=location,
+        limit_per_city=limit_per_city
+    )
+    
+    results["steps"].append({
+        "step": "scraping",
+        "leads_found": len(leads)
+    })
+    
+    if not leads:
+        print("⚠️ No se encontraron leads. Verifica tu APIFY_TOKEN.")
+        return results
+    
+    # Step 2: Enrichment
+    print("\n📍 PASO 2: Enriquecimiento de datos")
+    print("-" * 40)
+    
+    enriched_leads = enrich_leads(leads, delay=0.5)
+    
+    results["steps"].append({
+        "step": "enrichment",
+        "enriched_count": sum(1 for l in enriched_leads if l.get("email"))
+    })
+    
+    # Step 3: Store in database
+    print("\n📍 PASO 3: Guardando en base de datos")
+    print("-" * 40)
+    
+    added_count = 0
+    for lead in enriched_leads:
+        try:
+            lead_id = add_lead(lead)
+            added_count += 1
+            print(f"  ✅ ID:{lead_id} - {lead.get('name')}")
+        except Exception as e:
+            print(f"  ⚠️ Error: {e}")
+    
+    results["steps"].append({
+        "step": "database",
+        "added_count": added_count
+    })
+    
+    # Step 4: Generate outreach
+    print("\n📍 PASO 4: Preparando outreach")
+    print("-" * 40)
+    
+    # Get pending leads
+    pending_wa = get_pending_outreach("whatsapp", limit=10)
+    pending_email = get_pending_outreach("email", limit=10)
+    
+    print(f"  📱 WhatsApp pendientes: {len(pending_wa)}")
+    print(f"  📧 Email pendientes: {len(pending_email)}")
+    
+    # Generate WhatsApp links
+    if pending_wa:
+        wa_links = batch_generate_links(pending_wa)
+        results["steps"].append({
+            "step": "whatsapp_links",
+            "count": len(wa_links)
+        })
+    
+    # Show summary
+    print_header("📊 RESUMEN DEL PIPELINE")
+    
+    stats = get_stats()
+    results["stats"] = stats
+    
+    print(f"  Total leads en DB: {stats.get('total_leads', 0)}")
+    print(f"  Con email: {stats.get('with_email', 0)}")
+    print(f"  Enriquecidos: {stats.get('enriched', 0)}")
+    print(f"  WhatsApp enviados: {stats.get('whatsapp_sent', 0)}")
+    print(f"  Emails enviados: {stats.get('email_sent', 0)}")
+    
+    return results
+
+
+def run_scraping_only(
+    niche: str = "real_estate",
+    country: str = "usa",
+    location: Optional[str] = None,
+    limit: int = 10
+) -> int:
+    """Run only the scraping step."""
+    print_header(f"🔍 SCRAPING: {niche.upper()} / {country.upper()} ({location or 'default cities'})")
+    
+    leads = scrape_leads(niche=niche, country=country, location=location, limit_per_city=limit)
+    
+    if not leads:
+        print("⚠️ No se encontraron leads")
+        return 0
+    
+    # Enrich
+    enriched = enrich_leads(leads)
+    
+    # Save to DB
+    added = 0
+    for lead in enriched:
+        try:
+            add_lead(lead)
+            added += 1
+        except Exception as e:
+            pass
+    
+    print(f"\n✅ {added} leads agregados a la base de datos")
+    return added
+
+
+def run_whatsapp_outreach(limit: int = 10) -> List[Dict]:
+    """Generate WhatsApp links for pending leads."""
+    print_header("📱 OUTREACH: WhatsApp")
+    
+    pending = get_pending_outreach("whatsapp", limit=limit)
+    
+    if not pending:
+        print("✅ No hay leads pendientes de WhatsApp")
+        return []
+    
+    print(f"📋 {len(pending)} leads pendientes\n")
+    
+    results = batch_generate_links(pending)
+    
+    for i, result in enumerate(results):
+        if result.get("success"):
+            lead = pending[i]
+            # Save link to DB
+            mark_outreach(lead["id"], "whatsapp", result["link"])
+            
+            print(f"\n📱 {lead.get('name')}")
+            print(f"   📞 {result.get('phone')}")
+            print(f"   🔗 {result.get('link')[:60]}...")
+    
+    return results
+
+
+def run_email_outreach(limit: int = 10, preview_only: bool = True) -> List[Dict]:
+    """Send emails to pending leads."""
+    print_header("📧 OUTREACH: Email (Instantly.ai)")
+    
+    pending = get_pending_outreach("email", limit=limit)
+    
+    if not pending:
+        print("✅ No hay leads pendientes de email")
+        return []
+    
+    print(f"📋 {len(pending)} leads pendientes\n")
+    
+    config = load_config()
+    sender_name = config.get("sender", {}).get("name", "Your Name")
+    
+    if preview_only:
+        print("🔍 MODO PREVIEW (no se envían emails)\n")
+        for lead in pending[:3]:
+            demo_email_preview(lead, sender_name)
+        return []
+    else:
+        return batch_send_emails(pending, sender_name=sender_name)
+
+
+def show_dashboard():
+    """Print text-based dashboard."""
+    print_header("📊 DASHBOARD")
+    
+    stats = get_stats()
+    
+    print(f"📈 Total Leads: {stats.get('total_leads', 0)}")
+    print(f"📧 Con Email: {stats.get('with_email', 0)}")
+    print(f"✨ Enriquecidos: {stats.get('enriched', 0)}")
+    
+    print(f"\n📤 Outreach:")
+    print(f"   WhatsApp: {stats.get('whatsapp_sent', 0)}")
+    print(f"   Email: {stats.get('email_sent', 0)}")
+    print(f"   Respuestas: {stats.get('replied', 0)}")
+    
+    print(f"\n🏷️ Por Nicho:")
+    for niche, count in stats.get("by_niche", {}).items():
+        print(f"   {niche}: {count}")
+    
+    print(f"\n🌎 Por País:")
+    for country, count in stats.get("by_country", {}).items():
+        print(f"   {country}: {count}")
+    
+    opp = stats.get("opportunities", {})
+    if opp.get("count", 0) > 0:
+        print(f"\n💰 Oportunidades: {opp['count']} (${opp.get('total_value', 0):,.2f})")
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Lead Generation DOE Orchestrator")
+    parser.add_argument("--pipeline", action="store_true", help="Run full pipeline")
+    parser.add_argument("--scrape", action="store_true", help="Run scraping only")
+    parser.add_argument("--outreach-wa", action="store_true", help="Generate WhatsApp links")
+    parser.add_argument("--outreach-email", action="store_true", help="Send/preview emails")
+    parser.add_argument("--dashboard", action="store_true", help="Show dashboard")
+    parser.add_argument("--streamlit", action="store_true", help="Launch Streamlit dashboard")
+    parser.add_argument("--niche", choices=["real_estate", "insurance"], default="real_estate")
+    parser.add_argument("--country", choices=["usa", "venezuela"], default="usa")
+    parser.add_argument("--location", type=str, help="Specific City, State or ZIP")
+    parser.add_argument("--limit", type=int, default=10)
+    parser.add_argument("--demo", action="store_true", help="Demo mode")
+    
+    args = parser.parse_args()
+    
+    # Initialize DB
+    init_db()
+    
+    if args.pipeline:
+        run_full_pipeline(
+            niche=args.niche,
+            country=args.country,
+            location=args.location,
+            limit_per_city=args.limit,
+            demo=args.demo
+        )
+    elif args.scrape:
+        run_scraping_only(
+            niche=args.niche,
+            country=args.country,
+            location=args.location,
+            limit=args.limit
+        )
+    elif args.outreach_wa:
+        run_whatsapp_outreach(limit=args.limit)
+    elif args.outreach_email:
+        run_email_outreach(limit=args.limit, preview_only=True)
+    elif args.dashboard:
+        show_dashboard()
+    elif args.streamlit:
+        import subprocess
+        dashboard_path = os.path.join(os.path.dirname(__file__), "dashboard", "app.py")
+        subprocess.run(["streamlit", "run", dashboard_path])
+    else:
+        print("Comandos disponibles:")
+        print("  --pipeline      Ejecutar pipeline completo")
+        print("  --scrape        Solo scraping")
+        print("  --outreach-wa   Generar links WhatsApp")
+        print("  --outreach-email Preview emails")
+        print("  --dashboard     Dashboard texto")
+        print("  --streamlit     Dashboard web")

lead_gen_pro/l2_orchestration/orchestrator_pro.py

@@ -0,0 +1,486 @@
+"""
+L2 Orchestration: Pro Workflow Orchestrator - COMPLETAMENTE COMENTADO
+======================================================================
+
+Este es el orquestador avanzado (Capa L2) que coordina todo el flujo de trabajo
+del sistema de generación de leads. Implementa el pipeline completo con múltiples
+etapas de procesamiento.
+
+AUTOR: Lead Generation PRO System
+FECHA: 2025
+VERSION: 2.0
+
+ARQUITECTURA:
+- Nivel: L2 (Orquestación)
+- Patrón: Pipeline de procesamiento
+- Integra: Scrapers L3, Scoring L3, Database L3
+
+FLUJO DEL PIPELINE:
+1. Scraping B2B (Empresas) → LinkedIn, Google Maps, YouTube, etc.
+2. Scraping B2C (Consumidores) → Twitter, Reddit, YouTube, Facebook
+3. Higienización → Deduplicación de leads
+4. Scoring → Calificación de leads (MQL/SQL)
+5. Almacenamiento → SQLite database
+6. Webhooks → Notificación a sistemas externos (Make.com/n8n)
+
+DEPENDENCIAS:
+- l3_execution.apify_pro_scraper: Para scraping B2B
+- l3_execution.consumer_intent_scraper: Para scraping B2C
+- l3_execution.lead_scoring: Para calificación de leads
+- l3_execution.database_doe: Para persistencia de datos
+"""
+
+# =============================================================================
+# IMPORTS
+# =============================================================================
+
+import os              # Operaciones con sistema de archivos
+import sys             # Manipulación del path de Python
+import json            # Lectura/escritura de JSON (configuración)
+import requests        # Para enviar webhooks HTTP
+from datetime import datetime  # Manejo de fechas y timestamps
+from typing import Optional, List, Dict, Any  # Type hints para claridad
+
+# =============================================================================
+# CONFIGURACIÓN DE PATHS
+# =============================================================================
+
+# Añadir paths para módulos pro
+# Esto permite importar módulos desde directorios hermanos
+sys.path.insert(0, os.path.dirname(__file__))  # Directorio actual
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))  # Directorio padre
+
+# =============================================================================
+# IMPORTS DE MÓDULOS L3 (Capa de Ejecución)
+# =============================================================================
+
+# Scraper B2B: Extrae información de empresas desde múltiples plataformas
+from l3_execution.apify_pro_scraper import ProScraper
+
+# Scraper B2C: Detecta intención de compra en redes sociales
+from l3_execution.consumer_intent_scraper import scrape_b2c_leads
+
+# Scoring: Califica leads según múltiples criterios
+from l3_execution.lead_scoring import LeadScorer
+
+# Database: Persistencia de leads en SQLite
+from l3_execution.database_doe import add_lead, init_db
+
+# =============================================================================
+# CLASE PRINCIPAL: ProOrchestrator
+# =============================================================================
+
+class ProOrchestrator:
+    """
+    Orquestador principal del pipeline de generación de leads.
+    
+    Esta clase coordina todas las operaciones del sistema:
+    - Scraping de múltiples fuentes (B2B y B2C)
+    - Procesamiento y calificación de datos
+    - Almacenamiento persistente
+    - Notificaciones a sistemas externos
+    
+    ATRIBUTOS:
+        scraper (ProScraper): Instancia del scraper B2B
+        scorer (LeadScorer): Instancia del sistema de scoring
+        config (dict): Configuración cargada desde config.json
+    """
+    
+    def __init__(self):
+        """
+        Constructor de la clase. Inicializa los componentes necesarios.
+        
+        INICIALIZACIÓN:
+            1. ProScraper: Para scraping B2B
+            2. LeadScorer: Para calificación de leads
+            3. Config: Carga desde config.json
+        """
+        # Inicializar scraper B2B (LinkedIn, Google Maps, etc.)
+        self.scraper = ProScraper()
+        
+        # Inicializar sistema de scoring (calificación MQL/SQL)
+        self.scorer = LeadScorer()
+        
+        # Cargar configuración desde archivo JSON
+        self.config = self.load_config()
+    
+    def load_config(self):
+        """
+        Carga la configuración del sistema desde config.json.
+        
+        RETORNA:
+            dict: Configuración del sistema o diccionario vacío si no existe
+        
+        NOTA:
+            El archivo config.json debe estar en el directorio raíz del proyecto.
+            Contiene: tokens de API, webhooks, configuraciones de nichos, etc.
+        """
+        # Construir ruta al archivo de configuración
+        path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+        
+        # Verificar si el archivo existe
+        if os.path.exists(path):
+            # Abrir y leer el archivo JSON
+            with open(path, "r") as f:
+                return json.load(f)
+        
+        # Si no existe, retornar configuración vacía
+        return {}
+    
+    def send_webhook(self, lead: Dict[str, Any]):
+        """
+        Envía un lead calificado a un webhook externo (Make.com/n8n).
+        
+        PARÁMETROS:
+            lead (dict): Diccionario con la información del lead
+        
+        FUNCIONAMIENTO:
+            1. Lee la URL del webhook desde config.json (webhooks.new_lead)
+            2. Envía el lead como JSON vía POST
+            3. Timeout de 5 segundos para evitar bloqueos
+        
+        NOTA:
+            Solo se envían leads calificados como "SQL (Hot)" por el método run_pro_pipeline.
+        """
+        # Obtener URL del webhook desde configuración
+        webhook_url = self.config.get("webhooks", {}).get("new_lead")
+        
+        # Solo enviar si hay una URL configurada
+        if webhook_url:
+            try:
+                # Enviar lead como JSON con timeout de 5 segundos
+                requests.post(webhook_url, json=lead, timeout=5)
+            except Exception as e:
+                # Mostrar error pero no detener el pipeline
+                print(f"⚠️ Error enviando webhook: {e}")
+    
+    def run_pro_pipeline(
+        self, 
+        niche: str, 
+        region: str, 
+        location_data: Dict[str, str] = None,
+        lead_type: str = "both",
+        b2b_platforms: List[str] = None,
+        b2c_platforms: List[str] = None,
+        limit: int = 20
+    ):
+        """
+        MÉTODO PRINCIPAL: Ejecuta el pipeline completo de generación de leads.
+        
+        Este es el corazón del sistema. Coordina todas las etapas del proceso:
+        scraping → higienización → scoring → almacenamiento → webhooks.
+        
+        PARÁMETROS:
+            niche (str): Industria o nicho a buscar (ej: "Insurance", "Real Estate")
+            region (str): String de región legacy (ej: "CA Bay Area")
+            location_data (dict): Diccionario con 'city', 'state', 'country'
+            lead_type (str): Tipo de leads a buscar ('b2b', 'b2c', 'both')
+            b2b_platforms (list): Lista de plataformas B2B a escanear
+            b2c_platforms (list): Lista de plataformas B2C a escanear
+            limit (int): Límite de resultados por plataforma
+        
+        RETORNA:
+            list: Lista de leads procesados y calificados
+        
+        EJEMPLO:
+            orchestrator = ProOrchestrator()
+            leads = orchestrator.run_pro_pipeline(
+                niche="Insurance",
+                region="FL",
+                location_data={"city": "Miami", "state": "FL", "country": "USA"},
+                lead_type="both",
+                b2b_platforms=["linkedin", "google_maps"],
+                b2c_platforms=["twitter", "facebook"],
+                limit=20
+            )
+        """
+        
+        # -----------------------------------------------------------------
+        # PASO 1: PREPARACIÓN Y CONFIGURACIÓN
+        # -----------------------------------------------------------------
+        
+        # Determinar ubicación para logs y registros
+        # Si hay location_data, usarla; si no, usar region legacy
+        display_location = region
+        if location_data:
+            # Filtrar valores no vacíos y unirlos con comas
+            parts = [v for k, v in location_data.items() if v]
+            if parts:
+                display_location = ", ".join(parts)
+        
+        # Mostrar encabezado del pipeline
+        print(f"🚀 INICIANDO PIPELINE PRO: {niche} en {display_location}")
+        print(f"   Tipo de búsqueda: {lead_type.upper()}")
+        
+        # Inicializar lista para almacenar todos los leads
+        all_leads = []
+        
+        # -----------------------------------------------------------------
+        # PASO 2: SCRAPING B2B (EMPRESAS/NEGOCIOS)
+        # -----------------------------------------------------------------
+        
+        # Solo ejecutar si se solicitó B2B o ambos
+        if lead_type in ["b2b", "both"]:
+            print("\n--- B2B SCRAPING (Empresas) ---")
+            
+            # Usar plataformas por defecto si no se especificaron
+            b2b_platforms = b2b_platforms or ["linkedin", "google_maps"]
+            print(f"   Plataformas B2B: {', '.join(b2b_platforms)}")
+            
+            # Iterar sobre cada plataforma B2B seleccionada
+            for platform in b2b_platforms:
+                try:
+                    # Ejecutar scraping específico para esta plataforma
+                    raw_data = self._scrape_b2b_platform(
+                        platform=platform,
+                        niche=niche,
+                        location=display_location,
+                        location_data=location_data,
+                        limit=limit
+                    )
+                    
+                    # Procesar los resultados obtenidos
+                    for source, items in raw_data.items():
+                        for item in items:
+                            # Construir objeto lead estandarizado
+                            lead = {
+                                "name": item.get("name") or item.get("username") or item.get("title"),
+                                "email": item.get("email"),
+                                "phone": item.get("phone") or item.get("phoneNumber"),
+                                "linkedin_url": item.get("url") if source == "linkedin" else item.get("linkedin_url"),
+                                "company": item.get("company") or item.get("companyName"),
+                                "location": display_location,
+                                "city": location_data.get("city") if location_data else region.split(",")[0].strip(),
+                                "source_platform": source,
+                                "niche": niche,
+                                "type": "B2B",
+                                "scraped_at": datetime.now().isoformat()
+                            }
+                            all_leads.append(lead)
+                    
+                    # Mostrar resumen de esta plataforma
+                    print(f"✅ {platform}: {len(raw_data.get(platform, []))} leads encontrados")
+                    
+                except Exception as e:
+                    # Capturar errores pero continuar con otras plataformas
+                    print(f"⚠️ Error en {platform}: {e}")
+                    continue
+        
+        # -----------------------------------------------------------------
+        # PASO 3: SCRAPING B2C (CONSUMIDORES/INTENCIÓN DE COMPRA)
+        # -----------------------------------------------------------------
+        
+        # Solo ejecutar si se solicitó B2C o ambos
+        if lead_type in ["b2c", "both"]:
+            print("\n--- B2C SCRAPING (Consumidores) ---")
+            
+            # Usar plataformas por defecto si no se especificaron
+            b2c_platforms = b2c_platforms or ["youtube", "reddit", "twitter"]
+            print(f"   Plataformas B2C: {', '.join(b2c_platforms)}")
+            
+            # Definir keywords según el nicho
+            # Si es seguros, usar términos específicos; si no, términos genéricos
+            if "insurance" in niche.lower() or "seguro" in niche.lower():
+                keywords = ["necesito seguro", "busco seguro"]
+            else:
+                keywords = [f"looking for {niche}", f"need {niche}"]
+            
+            # Ejecutar scraping B2C con las plataformas seleccionadas
+            # Ajustar límite si es modo "both" (mitad para cada tipo)
+            b2c_leads = scrape_b2c_leads(
+                platforms=b2c_platforms, 
+                keywords=keywords, 
+                location=location_data,
+                limit_per_platform=limit//2 if lead_type == "both" else limit
+            )
+            
+            # Procesar los leads B2C obtenidos
+            for item in b2c_leads:
+                lead = {
+                    "name": item.get("username"),
+                    "email": None,  # B2C rara vez tiene email público directo
+                    "phone": None,
+                    "linkedin_url": item.get("url"),  # URL del post como referencia
+                    "company": "Consumer (B2C)",
+                    "location": display_location,
+                    "city": location_data.get("city") if location_data else "Unknown",
+                    "source_platform": item.get("platform"),
+                    "niche": niche,
+                    "type": "B2C",
+                    "intent_score": item.get("intent_score"),  # Score de intención de compra
+                    "content_snippet": item.get("content"),  # Contenido del post/comentario
+                    "scraped_at": datetime.now().isoformat()
+                }
+                all_leads.append(lead)
+            
+            # Mostrar resumen
+            print(f"✅ B2C: {len(b2c_leads)} leads encontrados")
+        
+        # -----------------------------------------------------------------
+        # PASO 4: HIGIENIZACIÓN Y DEDUPLICACIÓN
+        # -----------------------------------------------------------------
+        
+        # Eliminar leads duplicados basándose en email o nombre
+        # Usar diccionario para mantener solo un lead por clave única
+        unique_leads = {l["email"] or l["name"]: l for l in all_leads if l.get("email") or l.get("name")}.values()
+        print(f"\n🧹 Leads después de deduplicar: {len(unique_leads)}")
+        
+        # -----------------------------------------------------------------
+        # PASO 5: SCORING Y CALIFICACIÓN
+        # -----------------------------------------------------------------
+        
+        # Calificar cada lead según múltiples criterios:
+        # - Ubicación geográfica
+        # - Datos de contacto disponibles
+        # - Nicho/sector
+        # - Presencia en redes sociales
+        scored_leads = self.scorer.process_batch(list(unique_leads))
+        
+        # -----------------------------------------------------------------
+        # PASO 6: CONSOLIDACIÓN Y ALMACENAMIENTO
+        # -----------------------------------------------------------------
+        
+        # Guardar cada lead en la base de datos SQLite
+        for lead in scored_leads:
+            try:
+                # Guardar lead en BD (con upsert automático)
+                add_lead(lead)
+                
+                # Si el lead está calificado como "SQL (Hot)", enviar webhook
+                if lead.get("tier") == "SQL (Hot)":
+                    print(f"🔥 LEAD CALIFICADO: {lead['name']} ({lead['score']} pts)")
+                    self.send_webhook(lead)
+                    
+            except Exception as e:
+                # Mostrar error pero continuar con otros leads
+                print(f"⚠️ Error guardando lead: {e}")
+        
+        # -----------------------------------------------------------------
+        # PASO 7: RESUMEN FINAL
+        # -----------------------------------------------------------------
+        
+        print(f"\n✅ Pipeline Pro completado. {len(scored_leads)} leads procesados.")
+        return scored_leads
+    
+    def _scrape_b2b_platform(
+        self,
+        platform: str,
+        niche: str,
+        location: str,
+        location_data: Dict[str, str],
+        limit: int
+    ) -> Dict[str, List[Dict]]:
+        """
+        MÉTODO PRIVADO: Scrapea una plataforma B2B específica.
+        
+        Este método actúa como dispatcher que llama al método apropiado
+        del ProScraper según la plataforma seleccionada.
+        
+        PARÁMETROS:
+            platform (str): Nombre de la plataforma (linkedin, google_maps, etc.)
+            niche (str): Nicho/industria a buscar
+            location (str): Ubicación formateada para mostrar
+            location_data (dict): Datos de ubicación estructurados
+            limit (int): Límite de resultados
+        
+        RETORNA:
+            dict: Diccionario con los resultados organizados por fuente
+        
+        NOTA:
+            Cada plataforma tiene diferentes parámetros y formatos de búsqueda.
+            Este método normaliza las llamadas al scraper.
+        """
+        
+        # Inicializar diccionario de resultados
+        results = {}
+        
+        # -----------------------------------------------------------------
+        # LINKEDIN: Buscar profesionales
+        # -----------------------------------------------------------------
+        if platform == "linkedin":
+            # Buscar dueños y directores del nicho especificado
+            items = self.scraper.scrape_linkedin(
+                keywords=[f"{niche} owner", f"{niche} director"],
+                location=location,
+                limit=limit
+            )
+            results["linkedin"] = items
+        
+        # -----------------------------------------------------------------
+        # GOOGLE MAPS: Buscar negocios locales
+        # -----------------------------------------------------------------
+        elif platform == "google_maps":
+            # Buscar negocios del nicho en la ubicación especificada
+            items = self.scraper.scrape_google_maps(
+                search_terms=[f"{niche} in {location}"],
+                max_crawled_places=limit
+            )
+            results["google_maps"] = items
+        
+        # -----------------------------------------------------------------
+        # YOUTUBE: Buscar canales relacionados
+        # -----------------------------------------------------------------
+        elif platform == "youtube":
+            # Buscar videos relacionados con el nicho en la ubicación
+            items = self.scraper.scrape_youtube(
+                search_queries=[f"best {niche} in {location}", f"{niche} tips {location}"],
+                max_results=limit // 2  # Menor límite para YouTube
+            )
+            results["youtube"] = items
+        
+        # -----------------------------------------------------------------
+        # TIKTOK: Buscar por hashtags
+        # -----------------------------------------------------------------
+        elif platform == "tiktok":
+            # Scrapear por hashtags del nicho y ubicación
+            items = self.scraper.scrape_tiktok(
+                hashtags=[niche.replace(" ", ""), location.split(",")[0].lower()],
+                limit=limit // 2
+            )
+            results["tiktok"] = items
+        
+        # -----------------------------------------------------------------
+        # INSTAGRAM: Similar a TikTok (usa hashtags)
+        # -----------------------------------------------------------------
+        elif platform == "instagram":
+            # Instagram scraper usa hashtags similar a TikTok
+            items = self.scraper.scrape_tiktok(
+                hashtags=[niche.replace(" ", ""), location.split(",")[0].lower()],
+                limit=limit // 2
+            )
+            results["instagram"] = items
+        
+        return results
+
+# =============================================================================
+# PUNTO DE ENTRADA PARA PRUEBAS
+# =============================================================================
+
+if __name__ == "__main__":
+    """
+    Bloque de ejecución directa para pruebas del orquestador.
+    
+    Este código solo se ejecuta cuando se corre el archivo directamente,
+    no cuando se importa como módulo.
+    """
+    # Inicializar base de datos
+    init_db()
+    
+    # Crear instancia del orquestador
+    orchestrator = ProOrchestrator()
+    
+    # Ejecutar pipeline de prueba
+    print("\n" + "="*70)
+    print("EJECUCIÓN DE PRUEBA DEL PIPELINE")
+    print("="*70)
+    
+    orchestrator.run_pro_pipeline(
+        niche="Real Estate",
+        region="CA Bay Area",
+        lead_type="both",
+        limit=10
+    )
+
+# =============================================================================
+# FIN DEL ARCHIVO
+# =============================================================================

lead_gen_pro/l3_execution/__init__.py

@@ -0,0 +1 @@
+# __init__.py for l3_execution module

lead_gen_pro/l3_execution/apify_pro_scraper.py

@@ -0,0 +1,108 @@
+"""
+L3 Execution: Lead Gen Pro Scraper (Multi-platform)
+==================================================
+Scraper avanzado que integra LinkedIn, YouTube, TikTok e Instagram vía Apify API.
+"""
+
+import os
+import json
+import time
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+from apify_client import ApifyClient
+
+# Actor IDs actualizados según especificación
+PRO_ACTORS = {
+    "linkedin": "trudax/linkedin-people-search-scraper",  # REPLACED: Valid Public Actor
+    "youtube": "clank/youtube-scraper",
+    "tiktok": "clockworks/tiktok-scraper",
+    "instagram": "jaroslavsemanko/instagram-scraper",
+    "google_maps": "compass/crawler-google-places"
+}
+
+def get_apify_token():
+    config_path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            return json.load(f).get("apify_token")
+    return os.environ.get("APIFY_TOKEN")
+
+class ProScraper:
+    def __init__(self):
+        self.token = get_apify_token()
+        self.client = ApifyClient(self.token) if self.token else None
+
+    def scrape_linkedin(self, keywords: List[str], location: str, limit: int = 50):
+        if not self.client: return []
+        print(f"🔗 Scraping LinkedIn para: {keywords} en {location}...")
+        
+        # Trudax scraper expects 'searchTerms' list
+        # We combine keyword + location for better results without needing Geo URNs
+        combined_queries = [f"{k} {location}" for k in keywords]
+        
+        run_input = {
+            "searchTerms": combined_queries,
+            "limit": limit,
+        }
+        
+        try:
+            run = self.client.actor(PRO_ACTORS["linkedin"]).call(run_input=run_input)
+            return list(self.client.dataset(run["defaultDatasetId"]).iterate_items())
+        except Exception as e:
+             print(f"⚠️ Error en LinkedIn Scraper: {e}")
+             return []
+
+    def scrape_youtube(self, search_queries: List[str], max_results: int = 20):
+        if not self.client: return []
+        print(f"🎬 Scraping YouTube para: {search_queries}...")
+        run_input = {
+            "searchQueries": search_queries,
+            "maxResults": max_results,
+            "exportSubtitles": False
+        }
+        run = self.client.actor(PRO_ACTORS["youtube"]).call(run_input=run_input)
+        return list(self.client.dataset(run["defaultDatasetId"]).iterate_items())
+
+    def scrape_tiktok(self, hashtags: List[str], limit: int = 20):
+        if not self.client: return []
+        print(f"🎵 Scraping TikTok para hashtags: {hashtags}...")
+        run_input = {
+            "hashtags": hashtags,
+            "resultsPerPage": limit,
+            "shouldDownloadVideo": False
+        }
+        run = self.client.actor(PRO_ACTORS["tiktok"]).call(run_input=run_input)
+        return list(self.client.dataset(run["defaultDatasetId"]).iterate_items())
+
+    def scrape_google_maps(self, search_terms: List[str], max_crawled_places: int = 20):
+        if not self.client: return []
+        print(f"🗺️ Scraping Google Maps para: {search_terms}...")
+        run_input = {
+            "searchStrings": search_terms,
+            "maxCrawledPlacesPerSearch": max_crawled_places,
+            "onlyDataFromTopResult": False,
+        }
+        try:
+            run = self.client.actor(PRO_ACTORS["google_maps"]).call(run_input=run_input)
+            return list(self.client.dataset(run["defaultDatasetId"]).iterate_items())
+        except Exception as e:
+            print(f"⚠️ Error en Google Maps Scraper: {e}")
+            return []
+
+    def unified_scrape(self, niche: str, region: str, limit: int = 50):
+        """Pipeline de scraping unificado para múltiples plataformas."""
+        results = {
+            "linkedin": self.scrape_linkedin([f"{niche} owner", f"{niche} director"], region, limit),
+            "youtube": self.scrape_youtube([f"best {niche} in {region}", f"{niche} tips {region}"], limit // 2),
+            "tiktok": self.scrape_tiktok([niche.replace(" ", ""), region.split(",")[0].lower()], limit // 2),
+            "google_maps": self.scrape_google_maps([f"{niche} in {region}"], limit)
+        }
+        return results
+
+if __name__ == "__main__":
+    scraper = ProScraper()
+    # Test rápido
+    if scraper.token:
+        print("✅ Token detectado. Scraper Pro listo.")
+    else:
+        print("❌ Token no detectado. Revisa config.json.")

lead_gen_pro/l3_execution/apify_scraper.py

@@ -0,0 +1,266 @@
+"""
+L3 Execution: Apify Google Maps Scraper
+=========================================
+Script determinista para extraer leads de Google Maps usando Apify.
+Implementa la capa L3 del framework DOE.
+"""
+
+import os
+import json
+import time
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+# Apify client - will be installed in venv
+try:
+    from apify_client import ApifyClient
+    APIFY_AVAILABLE = True
+except ImportError:
+    APIFY_AVAILABLE = False
+    print("⚠️ apify-client no instalado. Ejecuta: pip install apify-client")
+
+
+# Apify Actor IDs (Free/Low-cost options)
+APIFY_ACTORS = {
+    "google_maps_basic": "compass/crawler-google-places",
+    "google_maps_extensive": "nwua9Gu5YrADL7ZDj",  # Free Google Maps Scraper
+    "google_maps_lead": "compass/crawler-google-places",
+}
+
+# Default cities for each country
+DEFAULT_CITIES = {
+    "usa": ["Miami, FL", "Houston, TX", "Los Angeles, CA", "New York, NY", "Chicago, IL"],
+    "venezuela": ["Caracas", "Maracaibo", "Valencia", "Barquisimeto", "Maracay"],
+}
+
+# Search queries by niche
+SEARCH_QUERIES = {
+    "real_estate": {
+        "usa": ["real estate agent", "realtor", "property broker"],
+        "venezuela": ["inmobiliaria", "agente inmobiliario", "bienes raices"],
+    },
+    "insurance": {
+        "usa": ["insurance agent", "insurance broker", "life insurance agent"],
+        "venezuela": ["corredor de seguros", "agente de seguros", "aseguradora"],
+    }
+}
+
+
+def get_config() -> Dict[str, Any]:
+    """Get full config."""
+    config_path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            return json.load(f)
+    return {}
+
+def get_queries_for_niche(niche: str, country: str) -> List[str]:
+    """Get search queries from config or fallback."""
+    config = get_config()
+    queries = config.get("niches", {}).get(niche, {}).get("queries", {}).get(country)
+    
+    if not queries:
+        # Fallback to hardcoded defaults
+        queries = SEARCH_QUERIES.get(niche, {}).get(country, [])
+        
+    return queries
+
+def get_apify_token() -> Optional[str]:
+    """Get Apify token from environment or config."""
+    token = os.environ.get("APIFY_TOKEN")
+    if token:
+        return token
+    
+    config_path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            config = json.load(f)
+            return config.get("apify_token")
+    
+    return None
+
+
+def scrape_google_maps_apify(
+    query: str,
+    location: str,
+    max_results: int = 20,
+    actor_id: str = "google_maps_lead"
+) -> List[Dict[str, Any]]:
+    """
+    Scrape Google Maps using Apify actor.
+    
+    Args:
+        query: Search query (e.g., "real estate agent")
+        location: Location string (e.g., "Miami, FL")
+        max_results: Maximum results to return
+        actor_id: Which Apify actor to use
+        
+    Returns:
+        List of business results.
+    """
+    token = get_apify_token()
+    if not token:
+        print("❌ APIFY_TOKEN no configurado. Usando modo demo.")
+        return demo_results(query, location)
+    
+    if not APIFY_AVAILABLE:
+        print("❌ apify-client no disponible.")
+        return demo_results(query, location)
+    
+    try:
+        client = ApifyClient(token)
+        
+        # Full actor ID
+        full_actor_id = APIFY_ACTORS.get(actor_id, actor_id)
+        
+        # Prepare input - format for compass/crawler-google-places
+        run_input = {
+            "searchStringsArray": [f"{query}"],
+            "locationQuery": location,
+            "maxCrawledPlacesPerSearch": max_results,
+            "language": "en",
+            "deeperCityScrape": False,
+        }
+        
+        print(f"🔍 Buscando: '{query}' en {location}...")
+        
+        # Run the actor
+        run = client.actor(full_actor_id).call(run_input=run_input)
+        
+        # Get results from dataset
+        results = []
+        for item in client.dataset(run["defaultDatasetId"]).iterate_items():
+            result = {
+                "name": item.get("title") or item.get("name"),
+                "phone": item.get("phone") or item.get("phoneNumber"),
+                "email": item.get("email"),
+                "address": item.get("address") or item.get("fullAddress"),
+                "website": item.get("website") or item.get("url"),
+                "rating": item.get("rating") or item.get("totalScore"),
+                "reviews_count": item.get("reviewsCount") or item.get("reviews"),
+                "place_id": item.get("placeId"),
+                "category": item.get("category") or item.get("type"),
+            }
+            results.append(result)
+        
+        print(f"✅ {len(results)} resultados encontrados")
+        return results
+        
+    except Exception as e:
+        print(f"❌ Error en Apify: {e}")
+        return demo_results(query, location)
+
+
+def demo_results(query: str, location: str) -> List[Dict[str, Any]]:
+    """Generate demo results for testing without API."""
+    demo_data = [
+        {
+            "name": f"Demo Business 1 - {location}",
+            "phone": "+1-555-0101",
+            "email": "demo1@example.com",
+            "address": f"123 Main St, {location}",
+            "website": "https://demo1.example.com",
+            "rating": 4.8,
+            "reviews_count": 150,
+            "category": query,
+        },
+        {
+            "name": f"Demo Business 2 - {location}",
+            "phone": "+1-555-0102",
+            "email": "demo2@example.com", 
+            "address": f"456 Oak Ave, {location}",
+            "website": "https://demo2.example.com",
+            "rating": 4.5,
+            "reviews_count": 89,
+            "category": query,
+        },
+    ]
+    print(f"🎭 Modo demo: {len(demo_data)} resultados generados")
+    return demo_data
+
+
+def scrape_leads(
+    niche: str,
+    country: str,
+    location: Optional[str] = None,
+    limit_per_city: int = 20
+) -> List[Dict[str, Any]]:
+    """
+    Scrape leads for a specific niche and country/location.
+    
+    Args:
+        niche: 'real_estate' or 'insurance'
+        country: 'usa' or 'venezuela'
+        location: Specific city, state or ZIP (optional)
+        limit_per_city: Max leads per location/query
+        
+    Returns:
+        List of lead dictionaries.
+    """
+    if location:
+        cities = [location]
+    else:
+        cities = DEFAULT_CITIES.get(country, [])[:3]
+    
+    queries = get_queries_for_niche(niche, country)
+    if not queries:
+        print(f"❌ No hay queries para {niche}/{country}")
+        return []
+    
+    all_leads = []
+    seen_phones = set()
+    
+    for city in cities:
+        for query in queries[:2]:  # Use first 2 queries
+            results = scrape_google_maps_apify(
+                query=query,
+                location=city,
+                max_results=limit_per_city
+            )
+            
+            for result in results:
+                phone = result.get("phone")
+                # Avoid duplicates
+                if phone and phone not in seen_phones:
+                    seen_phones.add(phone)
+                    
+                    lead = {
+                        **result,
+                        "source": "apify_google_maps",
+                        "niche": niche,
+                        "country": country,
+                        "city": city,
+                        "scraped_at": datetime.now().isoformat(),
+                    }
+                    all_leads.append(lead)
+            
+            # Rate limiting
+            time.sleep(2)
+    
+    print(f"\n📊 Total leads únicos: {len(all_leads)}")
+    return all_leads
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Apify Google Maps Scraper")
+    parser.add_argument("--niche", choices=["real_estate", "insurance"], default="real_estate")
+    parser.add_argument("--country", choices=["usa", "venezuela"], default="usa")
+    parser.add_argument("--limit", type=int, default=10)
+    parser.add_argument("--demo", action="store_true", help="Use demo mode")
+    
+    args = parser.parse_args()
+    
+    if args.demo:
+        print("🎭 Ejecutando en modo demo...")
+    
+    leads = scrape_leads(
+        niche=args.niche,
+        country=args.country,
+        limit_per_city=args.limit
+    )
+    
+    print(f"\n📋 Leads encontrados:")
+    for lead in leads[:5]:
+        print(f"  - {lead.get('name')} | {lead.get('phone')} | {lead.get('city')}")

lead_gen_pro/l3_execution/automation_engine.py

@@ -0,0 +1,80 @@
+import json
+import os
+from datetime import datetime
+
+class AutomationEngine:
+    """
+    Handles 'If-Then' automation rules for leads.
+    Rules are defined in config.json.
+    """
+    
+    def __init__(self, config_path=None):
+        if config_path is None:
+            config_path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+        self.config_path = config_path
+        self.config = self._load_config()
+        
+    def _load_config(self):
+        try:
+            if os.path.exists(self.config_path):
+                with open(self.config_path, "r") as f:
+                    return json.load(f)
+        except Exception as e:
+            print(f"[Automation] Error loading config: {e}")
+        return {}
+
+    def process_new_lead(self, lead_data):
+        """
+        Evaluates automation rules for a newly added lead.
+        """
+        rules = self.config.get("automation_rules", [])
+        if not rules:
+            # Default rule if none defined: if quality > 7, log it
+            if lead_data.get("quality_score", 0) >= 7:
+                print(f"[Automation] High quality lead detected: {lead_data.get('name')}")
+            return
+
+        for rule in rules:
+            if self._evaluate_condition(rule.get("if"), lead_data):
+                self._execute_action(rule.get("then"), lead_data)
+
+    def _evaluate_condition(self, condition, data):
+        """Simple condition evaluator: 'field', 'operator', 'value'"""
+        if not condition: return False
+        
+        field = condition.get("field")
+        op = condition.get("operator")
+        val = condition.get("value")
+        
+        data_val = data.get(field)
+        
+        if op == "==": return data_val == val
+        if op == ">=": return data_val >= val
+        if op == "<=": return data_val <= val
+        if op == "contains": return val in str(data_val)
+        
+        return False
+
+    def _execute_action(self, action, data):
+        """Executes the 'then' part of a rule."""
+        action_type = action.get("type")
+        
+        if action_type == "notify":
+            print(f"[NOTIFY] Automation triggered for {data.get('name')}: {action.get('message')}")
+        
+        elif action_type == "mark_priority":
+            # This would typically update the DB, but since we are called inside add_lead,
+            # we should modify the data object before it's finalized (if possible)
+            data["priority"] = action.get("value", 1)
+            print(f"[Automation] Lead {data.get('name')} marked as priority {data['priority']}")
+
+        elif action_type == "trigger_outreach":
+            channel = action.get("channel", "whatsapp")
+            print(f"[Automation] Triggering {channel} outreach for {data.get('name')}")
+            # Actual outreach logic would go here or be queued
+            
+if __name__ == "__main__":
+    # Test
+    engine = AutomationEngine()
+    sample_lead = {"name": "Test Automation", "quality_score": 9, "niche": "real_estate"}
+    engine.process_new_lead(sample_lead)

lead_gen_pro/l3_execution/consumer_intent_scraper.py

@@ -0,0 +1,729 @@
+"""
+L3 Execution: B2C Consumer Intent Scraper
+==========================================
+Script para detectar consumidores buscando activamente seguros en redes sociales.
+Implementa scraping de intención de compra en YouTube, Reddit y Twitter/X.
+"""
+
+import os
+import json
+import time
+import re
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+from urllib.parse import urlencode
+
+# Apify client - will be installed in venv
+try:
+    from apify_client import ApifyClient
+    APIFY_AVAILABLE = True
+except ImportError:
+    APIFY_AVAILABLE = False
+    print("⚠️ apify-client no instalado. Ejecuta: pip install apify-client")
+
+
+# Apify Actor IDs for social media scraping
+APIFY_ACTORS = {
+    "youtube_comments": "streamers/youtube-scraper",  # For comments
+    "reddit_posts": "trudax/reddit-scraper",  # For posts
+    "twitter_posts": "apidojo/tweet-scraper",  # For tweets
+    "facebook_posts": "apify/facebook-posts-scraper",  # For public posts and groups
+}
+
+# Keywords that indicate purchase intent (insurance-related)
+INTENT_KEYWORDS = {
+    "es": [
+        "necesito seguro", "busco seguro", "recomiendan seguro",
+        "seguro barato", "mejor seguro", "seguro de auto",
+        "seguro de vida", "seguro dental", "seguro médico",
+        "cotización seguro", "precio seguro", "cuánto cuesta seguro",
+        "me cancelaron el seguro", "mi seguro es caro",
+        "cambiar de aseguradora", "alternativa a seguro"
+    ],
+    "en": [
+        "need insurance", "looking for insurance", "recommend insurance",
+        "cheap insurance", "best insurance", "car insurance",
+        "life insurance", "dental insurance", "health insurance",
+        "insurance quote", "insurance price", "how much is insurance",
+        "my insurance cancelled", "my insurance is expensive",
+        "switch insurance", "insurance alternatives"
+    ]
+}
+
+# Keywords that indicate the user might be an agent/agency (to filter out)
+PROMOTIONAL_KEYWORDS = [
+    "agent", "agency", "broker", "vendo", "venta de seguros",
+    "corredor", "asesor", "consultor", "insurance agent",
+    "insurance broker", "sell insurance", "insurance sales"
+]
+
+# Complaint/negative sentiment indicators
+COMPLAINT_PATTERNS = [
+    r"too expensive", r"muy caro", r"overpriced",
+    r"cancelled", r"cancelaron", r"cancelaron mi",
+    r"bad experience", r"mala experiencia", r"terrible",
+    r"worst", r"peor", r"horrible",
+    r"problem", r"problema", r"issue", r"issues"
+]
+
+
+def get_apify_token():
+    """Obtiene el token de Apify desde config.json o variables de entorno."""
+    config_path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            return json.load(f).get("apify_token")
+    return os.environ.get("APIFY_TOKEN")
+
+
+class B2CScraper:
+    """
+    Scraper para detectar intención de compra de consumidores en redes sociales.
+    """
+    
+    def __init__(self):
+        self.apify_token = get_apify_token()
+        self.client = None
+        
+        if APIFY_AVAILABLE and self.apify_token:
+            self.client = ApifyClient(self.apify_token)
+        else:
+            print("⚠️ Apify no configurado. Usando modo demo.")
+    
+    def scrape_intent(
+        self,
+        platform: str,
+        keywords: List[str],
+        limit: int = 20,
+        language: str = "en"
+    ) -> List[Dict[str, Any]]:
+        """
+        Función orquestadora que decide qué scraper específico ejecutar.
+        
+        Args:
+            platform: 'youtube', 'reddit', o 'twitter'
+            keywords: Lista de frases clave a buscar
+            limit: Cantidad máxima de resultados
+            language: 'es' o 'en'
+            
+        Returns:
+            Lista de diccionarios con leads B2C detectados
+        """
+        print(f"🔍 Buscando intención de compra en {platform}...")
+        print(f"   Keywords: {keywords[:3]}...")
+        
+        if platform.lower() == "youtube":
+            return self._scrape_youtube(keywords, limit, language)
+        elif platform.lower() == "reddit":
+            return self._scrape_reddit(keywords, limit, language)
+        elif platform.lower() in ["twitter", "x"]:
+            return self._scrape_twitter(keywords, limit, language)
+        elif platform.lower() == "facebook":
+            return self._scrape_facebook(keywords, limit, language)
+        else:
+            print(f"❌ Plataforma no soportada: {platform}")
+            return []
+    
+    def _calculate_intent_score(self, content: str, username: str = "") -> tuple:
+        """
+        Calcula el score de intención de compra y el sentimiento.
+        
+        Returns:
+            Tuple de (intent_score: int, sentiment: str)
+        """
+        content_lower = content.lower()
+        username_lower = username.lower()
+        score = 50  # Base score
+        
+        # Check for promotional content (filter out)
+        for prom_keyword in PROMOTIONAL_KEYWORDS:
+            if prom_keyword in content_lower or prom_keyword in username_lower:
+                return (0, "promotional")  # Filter out
+        
+        # Check for intent keywords
+        for lang_keywords in INTENT_KEYWORDS.values():
+            for keyword in lang_keywords:
+                if keyword in content_lower:
+                    score += 15
+        
+        # Check for complaints (indicates need)
+        has_complaint = False
+        for pattern in COMPLAINT_PATTERNS:
+            if re.search(pattern, content_lower):
+                has_complaint = True
+                score += 10
+        
+        # Questions indicate high intent
+        if "?" in content:
+            score += 10
+        
+        # Cap score at 100
+        score = min(score, 100)
+        
+        # Determine sentiment
+        if has_complaint:
+            sentiment = "negative"
+        elif score > 70:
+            sentiment = "positive"
+        else:
+            sentiment = "neutral"
+        
+        return (score, sentiment)
+    
+    def _scrape_youtube(
+        self,
+        keywords: List[str],
+        limit: int,
+        language: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Scrapea comentarios de YouTube buscando intención de compra.
+        Busca videos relacionados con seguros y extrae comentarios recientes.
+        """
+        if not self.client:
+            return self._demo_results("youtube", keywords, limit)
+        
+        results = []
+        
+        try:
+            # Search for insurance-related videos
+            search_queries = keywords[:3] if keywords else ["insurance review", "best insurance 2024"]
+            
+            for query in search_queries:
+                print(f"   Buscando videos: '{query}'...")
+                
+                # Use YouTube scraper actor
+                run_input = {
+                    "searchKeywords": query,
+                    "maxResults": min(limit * 2, 20),
+                    "includeComments": True,
+                    "maxComments": 50,
+                }
+                
+                try:
+                    run = self.client.actor(APIFY_ACTORS["youtube_comments"]).call(run_input=run_input)
+                    
+                    for item in self.client.dataset(run["defaultDatasetId"]).iterate_items():
+                        # Process comments if available
+                        comments = item.get("comments", [])
+                        video_url = item.get("url", "")
+                        video_title = item.get("title", "")
+                        
+                        for comment in comments[:10]:  # Limit comments per video
+                            content = comment.get("text", "")
+                            username = comment.get("author", "")
+                            comment_url = comment.get("url", video_url)
+                            
+                            # Calculate intent
+                            intent_score, sentiment = self._calculate_intent_score(content, username)
+                            
+                            if intent_score >= 40:  # Only include if meaningful intent
+                                result = {
+                                    "platform": "youtube",
+                                    "username": username,
+                                    "content": content[:500],  # Limit content length
+                                    "url": comment_url,
+                                    "scraped_at": datetime.now().isoformat(),
+                                    "sentiment": sentiment,
+                                    "intent_score": intent_score,
+                                    "context": f"Video: {video_title[:100]}"
+                                }
+                                results.append(result)
+                    
+                    time.sleep(2)  # Rate limiting
+                    
+                except Exception as e:
+                    print(f"   ⚠️ Error procesando query '{query}': {e}")
+                    continue
+                
+                if len(results) >= limit:
+                    break
+        
+        except Exception as e:
+            print(f"❌ Error en YouTube scraper: {e}")
+            return self._demo_results("youtube", keywords, limit)
+        
+        print(f"✅ {len(results)} leads encontrados en YouTube")
+        return results[:limit]
+    
+    def _scrape_reddit(
+        self,
+        keywords: List[str],
+        limit: int,
+        language: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Scrapea posts de Reddit buscando intención de compra.
+        Busca en subreddits como r/Insurance, r/personalfinance, etc.
+        """
+        if not self.client:
+            return self._demo_results("reddit", keywords, limit)
+        
+        results = []
+        
+        try:
+            # Key subreddits for insurance discussions
+            subreddits = ["Insurance", "personalfinance", "askcarsales", "LifeInsurance"]
+            
+            for subreddit in subreddits:
+                if len(results) >= limit:
+                    break
+                
+                print(f"   Buscando en r/{subreddit}...")
+                
+                run_input = {
+                    "subreddits": [subreddit],
+                    "searchTerms": keywords[:3] if keywords else ["insurance"],
+                    "maxResults": min(limit * 2, 25),
+                    "sort": "new",
+                }
+                
+                try:
+                    run = self.client.actor(APIFY_ACTORS["reddit_posts"]).call(run_input=run_input)
+                    
+                    for item in self.client.dataset(run["defaultDatasetId"]).iterate_items():
+                        content = item.get("body", "") or item.get("title", "")
+                        username = item.get("author", "")
+                        post_url = item.get("url", "")
+                        
+                        # Calculate intent
+                        intent_score, sentiment = self._calculate_intent_score(content, username)
+                        
+                        if intent_score >= 40:
+                            result = {
+                                "platform": "reddit",
+                                "username": username,
+                                "content": content[:500],
+                                "url": post_url,
+                                "scraped_at": datetime.now().isoformat(),
+                                "sentiment": sentiment,
+                                "intent_score": intent_score,
+                                "context": f"r/{subreddit}"
+                            }
+                            results.append(result)
+                    
+                    time.sleep(2)  # Rate limiting
+                    
+                except Exception as e:
+                    print(f"   ⚠️ Error en r/{subreddit}: {e}")
+                    continue
+        
+        except Exception as e:
+            print(f"❌ Error en Reddit scraper: {e}")
+            return self._demo_results("reddit", keywords, limit)
+        
+        print(f"✅ {len(results)} leads encontrados en Reddit")
+        return results[:limit]
+    
+    def _scrape_twitter(
+        self,
+        keywords: List[str],
+        limit: int,
+        language: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Scrapea tweets buscando intención de compra.
+        """
+        if not self.client:
+            return self._demo_results("twitter", keywords, limit)
+        
+        results = []
+        
+        try:
+            # Build search query
+            search_terms = keywords[:3] if keywords else ["need insurance", "looking for insurance"]
+            
+            for term in search_terms:
+                if len(results) >= limit:
+                    break
+                
+                print(f"   Buscando tweets: '{term}'...")
+                
+                run_input = {
+                    "searchTerms": [term],
+                    "maxTweets": min(limit * 2, 30),
+                    "includeReplies": False,
+                    "language": language,
+                }
+                
+                try:
+                    run = self.client.actor(APIFY_ACTORS["twitter_posts"]).call(run_input=run_input)
+                    
+                    for item in self.client.dataset(run["defaultDatasetId"]).iterate_items():
+                        content = item.get("text", "")
+                        username = item.get("username", "").replace("@", "")
+                        tweet_url = item.get("url", f"https://twitter.com/{username}/status/{item.get('id', '')}")
+                        
+                        # Calculate intent
+                        intent_score, sentiment = self._calculate_intent_score(content, username)
+                        
+                        if intent_score >= 40:
+                            result = {
+                                "platform": "twitter",
+                                "username": username,
+                                "content": content[:500],
+                                "url": tweet_url,
+                                "scraped_at": datetime.now().isoformat(),
+                                "sentiment": sentiment,
+                                "intent_score": intent_score,
+                                "context": None
+                            }
+                            results.append(result)
+                    
+                    time.sleep(2)  # Rate limiting
+                    
+                except Exception as e:
+                    print(f"   ⚠️ Error buscando '{term}': {e}")
+                    continue
+        
+        except Exception as e:
+            print(f"❌ Error en Twitter scraper: {e}")
+            return self._demo_results("twitter", keywords, limit)
+        
+        print(f"✅ {len(results)} leads encontrados en Twitter")
+        return results[:limit]
+    
+    def _scrape_facebook(
+        self,
+        keywords: List[str],
+        limit: int,
+        language: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Scrapea posts públicos de Facebook buscando intención de compra.
+        Busca en grupos públicos y posts públicos relacionados con seguros.
+        Ideal para leads B2C en Florida y USA.
+        """
+        if not self.client:
+            return self._demo_results("facebook", keywords, limit)
+        
+        results = []
+        
+        try:
+            # Search terms específicos para seguros
+            search_terms = keywords[:3] if keywords else [
+                "need insurance Florida",
+                "looking for insurance Miami",
+                "cheap insurance Orlando",
+                "car insurance Tampa",
+                "health insurance Florida"
+            ]
+            
+            for term in search_terms:
+                if len(results) >= limit:
+                    break
+                
+                print(f"   Buscando en Facebook: '{term}'...")
+                
+                run_input = {
+                    "searchTerms": [term],
+                    "maxResults": min(limit * 2, 30),
+                    "onlyPosts": True,
+                    "includeComments": False,
+                }
+                
+                try:
+                    run = self.client.actor(APIFY_ACTORS["facebook_posts"]).call(run_input=run_input)
+                    
+                    for item in self.client.dataset(run["defaultDatasetId"]).iterate_items():
+                        content = item.get("text", "")
+                        username = item.get("user", {}).get("name", "Unknown")
+                        user_url = item.get("user", {}).get("url", "")
+                        post_url = item.get("url", "")
+                        group_name = item.get("group", {}).get("name", "")
+                        
+                        # Calculate intent
+                        intent_score, sentiment = self._calculate_intent_score(content, username)
+                        
+                        if intent_score >= 40:
+                            result = {
+                                "platform": "facebook",
+                                "username": username,
+                                "content": content[:500],
+                                "url": post_url or user_url,
+                                "scraped_at": datetime.now().isoformat(),
+                                "sentiment": sentiment,
+                                "intent_score": intent_score,
+                                "context": f"Group: {group_name}" if group_name else "Public Post"
+                            }
+                            results.append(result)
+                    
+                    time.sleep(3)  # Rate limiting (Facebook es más estricto)
+                    
+                except Exception as e:
+                    print(f"   ⚠️ Error buscando '{term}': {e}")
+                    continue
+        
+        except Exception as e:
+            print(f"❌ Error en Facebook scraper: {e}")
+            return self._demo_results("facebook", keywords, limit)
+        
+        print(f"✅ {len(results)} leads encontrados en Facebook")
+        return results[:limit]
+    
+    def _demo_results(
+        self,
+        platform: str,
+        keywords: List[str],
+        limit: int
+    ) -> List[Dict[str, Any]]:
+        """Genera resultados demo para pruebas sin API."""
+        demo_data = {
+            "youtube": [
+                {
+                    "platform": "youtube",
+                    "username": "consumer_john_2024",
+                    "content": "Necesito un seguro de auto barato en Miami. Alguien tiene recomendaciones? Mi seguro actual es muy caro.",
+                    "url": "https://youtube.com/watch?v=demo1",
+                    "sentiment": "negative",
+                    "intent_score": 85,
+                    "context": "Video: Best Car Insurance 2024"
+                },
+                {
+                    "platform": "youtube",
+                    "username": "sarah_smith",
+                    "content": "Looking for dental insurance recommendations. My current plan doesn't cover what I need. Help!",
+                    "url": "https://youtube.com/watch?v=demo2",
+                    "sentiment": "negative",
+                    "intent_score": 78,
+                    "context": "Video: Dental Insurance Guide"
+                },
+            ],
+            "reddit": [
+                {
+                    "platform": "reddit",
+                    "username": "insurance_seeker_22",
+                    "content": "Just got my insurance cancelled. Need a new provider ASAP. Any recommendations for affordable life insurance?",
+                    "url": "https://reddit.com/r/Insurance/demo1",
+                    "sentiment": "negative",
+                    "intent_score": 92,
+                    "context": "r/Insurance"
+                },
+                {
+                    "platform": "reddit",
+                    "username": "budget_mom",
+                    "content": "What's the best health insurance for a family of 4? Currently paying $800/month and it's killing us.",
+                    "url": "https://reddit.com/r/personalfinance/demo2",
+                    "sentiment": "negative",
+                    "intent_score": 88,
+                    "context": "r/personalfinance"
+                },
+            ],
+            "twitter": [
+                {
+                    "platform": "twitter",
+                    "username": "mike_looking",
+                    "content": "Need car insurance quotes ASAP! My current provider raised rates by 40%. Anyone have good experiences with Geico or Progressive?",
+                    "url": "https://twitter.com/mike_looking/status/demo1",
+                    "sentiment": "negative",
+                    "intent_score": 90,
+                    "context": None
+                },
+                {
+                    "platform": "twitter",
+                    "username": "young_professional",
+                    "content": "First time buying life insurance. What should I look for? Term vs whole life? #insurance #help",
+                    "url": "https://twitter.com/young_professional/status/demo2",
+                    "sentiment": "neutral",
+                    "intent_score": 75,
+                    "context": None
+                },
+            ],
+            "facebook": [
+                {
+                    "platform": "facebook",
+                    "username": "Sarah Johnson",
+                    "content": "Hi everyone! Just moved to Florida and need car insurance recommendations. My previous insurer doesn't cover this state. Any suggestions for affordable options in Miami?",
+                    "url": "https://facebook.com/groups/florida-insurance/posts/demo1",
+                    "sentiment": "neutral",
+                    "intent_score": 82,
+                    "context": "Group: Florida Insurance Help"
+                },
+                {
+                    "platform": "facebook",
+                    "username": "Carlos Martinez",
+                    "content": "Desperate for dental insurance in Orlando! My dentist says I need a root canal ASAP but my current plan won't cover it. Anyone know of good dental insurance that covers major procedures?",
+                    "url": "https://facebook.com/groups/orlando-community/posts/demo2",
+                    "sentiment": "negative",
+                    "intent_score": 95,
+                    "context": "Group: Orlando Community"
+                },
+                {
+                    "platform": "facebook",
+                    "username": "Jennifer Williams",
+                    "content": "Looking for health insurance for my family of 5 in Tampa. Self-employed so no employer plan. What are my best options? Marketplace or private?",
+                    "url": "https://facebook.com/groups/tampa-moms/posts/demo3",
+                    "sentiment": "neutral",
+                    "intent_score": 78,
+                    "context": "Group: Tampa Moms Group"
+                },
+            ]
+        }
+        
+        platform_data = demo_data.get(platform, [])
+        results = []
+        
+        for item in platform_data[:limit]:
+            item_copy = item.copy()
+            item_copy["scraped_at"] = datetime.now().isoformat()
+            results.append(item_copy)
+        
+        print(f"🎭 Modo demo: {len(results)} resultados generados para {platform}")
+        return results
+
+
+def scrape_b2c_leads(
+    platforms: List[str] = None,
+    keywords: List[str] = None,
+    location: Dict[str, str] = None,
+    limit_per_platform: int = 10,
+    language: str = "en"
+) -> List[Dict[str, Any]]:
+    """
+    Función principal para scrapear leads B2C de múltiples plataformas.
+    Soporta segmentación geográfica granular.
+    
+    Args:
+        platforms: Lista de plataformas ('youtube', 'reddit', 'twitter')
+        keywords: Lista de keywords base (opcional)
+        location: Dict con 'city', 'state', 'country'
+        limit_per_platform: Máximo de resultados por plataforma
+        language: Idioma ('es' o 'en')
+    """
+    if platforms is None:
+        platforms = ["youtube", "reddit", "twitter"]
+    
+    # Base keywords if not provided
+    if keywords is None:
+        keywords = INTENT_KEYWORDS.get(language, INTENT_KEYWORDS["en"])
+    
+    # Generate location-specific keywords
+    targeted_keywords = keywords.copy()
+    if location:
+        city = location.get("city")
+        state = location.get("state")
+        country = location.get("country")
+        
+        location_terms = [term for term in [city, state, country] if term]
+        
+        if location_terms:
+            print(f"📍 Aplicando segmentación geográfica: {', '.join(location_terms)}")
+            geo_keywords = []
+            for kw in keywords:
+                for term in location_terms:
+                    geo_keywords.append(f"{kw} {term}")
+                    geo_keywords.append(f"{kw} in {term}" if language == "en" else f"{kw} en {term}")
+            
+            # Add specific geo keywords to the top of the list
+            targeted_keywords = geo_keywords + keywords
+            
+    scraper = B2CScraper()
+    all_leads = []
+    
+    for platform in platforms:
+        try:
+            leads = scraper.scrape_intent(
+                platform=platform,
+                keywords=targeted_keywords,
+                limit=limit_per_platform,
+                language=language
+            )
+            all_leads.extend(leads)
+            
+            # Rate limiting entre plataformas
+            if platform != platforms[-1]:
+                time.sleep(3)
+        except Exception as e:
+            print(f"⚠️ Error en plataforma {platform}: {e}")
+    
+    # Sort by intent score (highest first)
+    all_leads.sort(key=lambda x: x.get("intent_score", 0), reverse=True)
+    
+    print(f"\n📊 Total leads B2C únicos: {len(all_leads)}")
+    return all_leads
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="B2C Consumer Intent Scraper")
+    parser.add_argument(
+        "--platform",
+        choices=["youtube", "reddit", "twitter", "all"],
+        default="all",
+        help="Plataforma a scrapear"
+    )
+    parser.add_argument(
+        "--keywords",
+        nargs="+",
+        default=None,
+        help="Keywords a buscar (separados por espacio)"
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=10,
+        help="Máximo de resultados por plataforma"
+    )
+    parser.add_argument(
+        "--language",
+        choices=["es", "en"],
+        default="en",
+        help="Idioma de búsqueda"
+    )
+    parser.add_argument(
+        "--demo",
+        action="store_true",
+        help="Usar modo demo (sin APIs)"
+    )
+    # Location args
+    parser.add_argument("--city", type=str, help="Ciudad")
+    parser.add_argument("--state", type=str, help="Estado")
+    parser.add_argument("--country", type=str, help="País")
+    
+    args = parser.parse_args()
+    
+    # Setup platforms
+    if args.platform == "all":
+        platforms = ["youtube", "reddit", "twitter"]
+    else:
+        platforms = [args.platform]
+
+    # Setup location
+    location = {}
+    if args.city: location["city"] = args.city
+    if args.state: location["state"] = args.state
+    if args.country: location["country"] = args.country
+    
+    print("🎯 B2C Consumer Intent Scraper")
+    print("=" * 50)
+    print(f"Plataformas: {', '.join(platforms)}")
+    print(f"Keywords: {args.keywords or 'Default'}")
+    print(f"Ubicación: {location if location else 'Global'}")
+    print(f"Límite por plataforma: {args.limit}")
+    print(f"Idioma: {args.language}")
+    print("=" * 50)
+    
+    # Run scraper
+    leads = scrape_b2c_leads(
+        platforms=platforms,
+        keywords=args.keywords,
+        location=location,
+        limit_per_platform=args.limit,
+        language=args.language
+    )
+    
+    # Display results
+    print(f"\n📋 Top Leads B2C Detectados:")
+    print("-" * 80)
+    for i, lead in enumerate(leads[:10], 1):
+        print(f"\n{i}. [{lead['platform'].upper()}] Score: {lead['intent_score']}/100")
+        print(f"   Usuario: @{lead['username']}")
+        print(f"   Contenido: {lead['content'][:150]}...")
+        print(f"   Sentimiento: {lead['sentiment']}")
+        print(f"   URL: {lead['url']}")
+        if lead.get('context'):
+            print(f"   Contexto: {lead['context']}")
+    
+    print("\n" + "=" * 80)
+    print(f"✅ Proceso completado. {len(leads)} leads B2C detectados.")

lead_gen_pro/l3_execution/database_doe.py

@@ -0,0 +1,480 @@
+"""
+L3 Execution: Enhanced Database Module
+========================================
+Base de datos SQLite expandida con soporte para contactos, 
+oportunidades e historial de outreach.
+Implementa la capa L3 del framework DOE.
+"""
+
+import sqlite3
+import os
+import json
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+# NexusCRM Fase 2 Cloud Sync
+try:
+    from l3_execution.supabase_sync import sync_lead_to_supabase
+    from l3_execution.automation_engine import AutomationEngine
+except ImportError:
+    try:
+        from supabase_sync import sync_lead_to_supabase
+        from automation_engine import AutomationEngine
+    except ImportError:
+        def sync_lead_to_supabase(data): pass
+        class AutomationEngine: 
+            def process_new_lead(self, data): pass
+
+automation = AutomationEngine()
+
+DB_PATH = os.path.join(os.path.dirname(__file__), "..", "leads_doe.db")
+
+
+def get_connection(timeout: int = 30) -> sqlite3.Connection:
+    """Get database connection with row factory and timeout.
+    
+    Args:
+        timeout: Seconds to wait for database lock (default: 30)
+    
+    Returns:
+        sqlite3.Connection with row factory enabled
+    """
+    conn = sqlite3.connect(DB_PATH, timeout=timeout)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_db() -> None:
+    """Initialize database with enhanced schema."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    # Main leads table
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS leads (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            phone TEXT,
+            phone_formatted TEXT,
+            email TEXT,
+            address TEXT,
+            website TEXT,
+            rating REAL,
+            reviews_count INTEGER,
+            category TEXT,
+            source TEXT DEFAULT 'apify',
+            niche TEXT NOT NULL,
+            country TEXT NOT NULL,
+            city TEXT,
+            
+            -- Enrichment data
+            enriched BOOLEAN DEFAULT 0,
+            facebook_url TEXT,
+            instagram_url TEXT,
+            linkedin_url TEXT,
+            twitter_url TEXT,
+            
+            -- Status tracking
+            status TEXT DEFAULT 'new',
+            priority INTEGER DEFAULT 0,
+            
+            -- Outreach status
+            whatsapp_sent BOOLEAN DEFAULT 0,
+            whatsapp_sent_at TIMESTAMP,
+            whatsapp_link TEXT,
+            email_sent BOOLEAN DEFAULT 0,
+            email_sent_at TIMESTAMP,
+            replied BOOLEAN DEFAULT 0,
+            replied_at TIMESTAMP,
+            
+            -- Opportunity tracking
+            is_opportunity BOOLEAN DEFAULT 0,
+            opportunity_value REAL,
+            opportunity_notes TEXT,
+            
+            -- Metadata
+            scraped_at TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    
+    # Outreach history log
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS outreach_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            lead_id INTEGER NOT NULL,
+            channel TEXT NOT NULL,
+            message_template TEXT,
+            message_sent TEXT,
+            status TEXT DEFAULT 'sent',
+            response TEXT,
+            sent_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (lead_id) REFERENCES leads(id)
+        )
+    """)
+    
+    # Opportunities (CRM-like)
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS opportunities (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            lead_id INTEGER NOT NULL,
+            stage TEXT DEFAULT 'qualified',
+            value REAL,
+            probability INTEGER DEFAULT 50,
+            notes TEXT,
+            next_action TEXT,
+            next_action_date DATE,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (lead_id) REFERENCES leads(id)
+        )
+    """)
+    
+    # Dashboard metrics cache
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS metrics (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            metric_name TEXT NOT NULL,
+            metric_value TEXT,
+            calculated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    
+    # Create indexes
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_leads_status ON leads(status)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_leads_niche ON leads(niche)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_leads_country ON leads(country)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_leads_email ON leads(email)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_outreach_lead ON outreach_log(lead_id)")
+    
+    conn.commit()
+    conn.close()
+    
+    print(f"[OK] Base de datos DOE inicializada: {DB_PATH}")
+
+
+def add_lead(lead_data: Dict[str, Any], upsert: bool = True) -> int:
+    """
+    Add a new lead to the database.
+    If upsert is True, it updates existing lead based on phone or email.
+    """
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    phone = lead_data.get("phone")
+    email = lead_data.get("email")
+    
+    # Check for existing lead (Deduplication)
+    existing_id = None
+    if phone:
+        cursor.execute("SELECT id FROM leads WHERE phone = ? OR phone_formatted = ?", (phone, phone))
+        row = cursor.fetchone()
+        if row: existing_id = row[0]
+        
+    if not existing_id and email:
+        cursor.execute("SELECT id FROM leads WHERE email = ?", (email,))
+        row = cursor.fetchone()
+        if row: existing_id = row[0]
+    
+    if existing_id:
+        if not upsert:
+            conn.close()
+            return existing_id
+        
+        # Update existing lead (Upsert logic)
+        # Extract social profiles if present
+        social = lead_data.get("social_profiles", {})
+        
+        cursor.execute("""
+            UPDATE leads 
+            SET name = COALESCE(?, name),
+                email = COALESCE(?, email),
+                address = COALESCE(?, address),
+                website = COALESCE(?, website),
+                rating = COALESCE(?, rating),
+                whatsapp_link = COALESCE(?, whatsapp_link),
+                facebook_url = COALESCE(?, facebook_url),
+                instagram_url = COALESCE(?, instagram_url),
+                linkedin_url = COALESCE(?, linkedin_url),
+                twitter_url = COALESCE(?, twitter_url),
+                quality_score = COALESCE(?, quality_score),
+                updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        """, (
+            lead_data.get("name"),
+            lead_data.get("email"),
+            lead_data.get("address"),
+            lead_data.get("website"),
+            lead_data.get("rating"),
+            lead_data.get("whatsapp_link"),
+            social.get("facebook") if isinstance(social, dict) else None,
+            social.get("instagram") if isinstance(social, dict) else None,
+            social.get("linkedin") if isinstance(social, dict) else None,
+            social.get("twitter") if isinstance(social, dict) else None,
+            lead_data.get("quality_score"),
+            existing_id
+        ))
+        lead_id = existing_id
+    else:
+        # Extract social profiles if present
+        social = lead_data.get("social_profiles", {})
+        
+        cursor.execute("""
+            INSERT INTO leads (
+                name, phone, phone_formatted, email, address, website,
+                rating, reviews_count, category, source, niche, country, city,
+                enriched, facebook_url, instagram_url, linkedin_url, twitter_url,
+                whatsapp_link, quality_score, scraped_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            lead_data.get("name"),
+            lead_data.get("phone"),
+            lead_data.get("phone_formatted"),
+            lead_data.get("email"),
+            lead_data.get("address"),
+            lead_data.get("website"),
+            lead_data.get("rating"),
+            lead_data.get("reviews_count"),
+            lead_data.get("category"),
+            lead_data.get("source", "apify"),
+            lead_data.get("niche"),
+            lead_data.get("country"),
+            lead_data.get("city"),
+            lead_data.get("enriched", False),
+            social.get("facebook") if isinstance(social, dict) else None,
+            social.get("instagram") if isinstance(social, dict) else None,
+            social.get("linkedin") if isinstance(social, dict) else None,
+            social.get("twitter") if isinstance(social, dict) else None,
+            lead_data.get("whatsapp_link"),
+            lead_data.get("quality_score"),
+            lead_data.get("scraped_at")
+        ))
+        lead_id = cursor.lastrowid
+    
+    conn.commit()
+    conn.close()
+    
+    # Proactive Sync to NexusCRM Supabase Cloud (Fase 2)
+    try:
+        sync_lead_to_supabase(lead_data)
+    except Exception as e:
+        print(f"[NexusCRM] Warning: Auto-sync to cloud failed: {e}")
+
+    # Process Automation Rules (Fase 2)
+    try:
+        automation.process_new_lead(lead_data)
+    except Exception as e:
+        print(f"[Automation] Warning: Rule processing failed: {e}")
+    
+    return lead_id
+
+
+def get_leads(
+    niche: Optional[str] = None,
+    country: Optional[str] = None,
+    status: Optional[str] = None,
+    with_email: bool = False,
+    with_phone: bool = False,
+    limit: int = 100
+) -> List[Dict[str, Any]]:
+    """Get leads with optional filters."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    query = "SELECT * FROM leads WHERE 1=1"
+    params = []
+    
+    if niche:
+        query += " AND niche = ?"
+        params.append(niche)
+    if country:
+        query += " AND country = ?"
+        params.append(country)
+    if status:
+        query += " AND status = ?"
+        params.append(status)
+    if with_email:
+        query += " AND email IS NOT NULL AND email != ''"
+    if with_phone:
+        query += " AND phone IS NOT NULL AND phone != ''"
+    
+    query += " ORDER BY created_at DESC LIMIT ?"
+    params.append(limit)
+    
+    cursor.execute(query, params)
+    rows = cursor.fetchall()
+    conn.close()
+    
+    return [dict(row) for row in rows]
+
+
+def get_pending_outreach(
+    channel: str,
+    niche: Optional[str] = None,
+    limit: int = 20
+) -> List[Dict[str, Any]]:
+    """Get leads pending outreach for a specific channel."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    query = "SELECT * FROM leads WHERE status = 'new'"
+    params = []
+    
+    if channel == "whatsapp":
+        query += " AND whatsapp_sent = 0 AND phone IS NOT NULL"
+    elif channel == "email":
+        query += " AND email_sent = 0 AND email IS NOT NULL"
+    
+    if niche:
+        query += " AND niche = ?"
+        params.append(niche)
+    
+    query += " ORDER BY priority DESC, rating DESC LIMIT ?"
+    params.append(limit)
+    
+    cursor.execute(query, params)
+    rows = cursor.fetchall()
+    conn.close()
+    
+    return [dict(row) for row in rows]
+
+
+def mark_outreach(
+    lead_id: int,
+    channel: str,
+    message: str,
+    status: str = "sent"
+) -> None:
+    """Mark outreach as sent and log it."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    now = datetime.now().isoformat()
+    
+    # Update lead
+    if channel == "whatsapp":
+        cursor.execute("""
+            UPDATE leads 
+            SET whatsapp_sent = 1, whatsapp_sent_at = ?, whatsapp_link = ?, status = 'contacted'
+            WHERE id = ?
+        """, (now, message, lead_id))
+    elif channel == "email":
+        cursor.execute("""
+            UPDATE leads 
+            SET email_sent = 1, email_sent_at = ?, status = 'contacted'
+            WHERE id = ?
+        """, (now, lead_id))
+    
+    # Log outreach
+    cursor.execute("""
+        INSERT INTO outreach_log (lead_id, channel, message_sent, status)
+        VALUES (?, ?, ?, ?)
+    """, (lead_id, channel, message, status))
+    
+    conn.commit()
+    conn.close()
+
+
+def create_opportunity(
+    lead_id: int,
+    value: float,
+    notes: str = "",
+    stage: str = "qualified"
+) -> int:
+    """Create an opportunity from a lead."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    # Mark lead as opportunity
+    cursor.execute("""
+        UPDATE leads 
+        SET is_opportunity = 1, opportunity_value = ?, opportunity_notes = ?
+        WHERE id = ?
+    """, (value, notes, lead_id))
+    
+    # Create opportunity record
+    cursor.execute("""
+        INSERT INTO opportunities (lead_id, stage, value, notes)
+        VALUES (?, ?, ?, ?)
+    """, (lead_id, stage, value, notes))
+    
+    opp_id = cursor.lastrowid
+    conn.commit()
+    conn.close()
+    
+    return opp_id
+
+
+def get_stats() -> Dict[str, Any]:
+    """Get comprehensive statistics."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    
+    stats = {}
+    
+    # Total leads
+    cursor.execute("SELECT COUNT(*) FROM leads")
+    stats["total_leads"] = cursor.fetchone()[0]
+    
+    # By status
+    cursor.execute("SELECT status, COUNT(*) FROM leads GROUP BY status")
+    stats["by_status"] = dict(cursor.fetchall())
+    
+    # By niche
+    cursor.execute("SELECT niche, COUNT(*) FROM leads GROUP BY niche")
+    stats["by_niche"] = dict(cursor.fetchall())
+    
+    # By country
+    cursor.execute("SELECT country, COUNT(*) FROM leads GROUP BY country")
+    stats["by_country"] = dict(cursor.fetchall())
+    
+    # Enrichment stats
+    cursor.execute("SELECT COUNT(*) FROM leads WHERE enriched = 1")
+    stats["enriched"] = cursor.fetchone()[0]
+    
+    cursor.execute("SELECT COUNT(*) FROM leads WHERE email IS NOT NULL")
+    stats["with_email"] = cursor.fetchone()[0]
+    
+    # Outreach stats
+    cursor.execute("SELECT COUNT(*) FROM leads WHERE whatsapp_sent = 1")
+    stats["whatsapp_sent"] = cursor.fetchone()[0]
+    
+    cursor.execute("SELECT COUNT(*) FROM leads WHERE email_sent = 1")
+    stats["email_sent"] = cursor.fetchone()[0]
+    
+    cursor.execute("SELECT COUNT(*) FROM leads WHERE replied = 1")
+    stats["replied"] = cursor.fetchone()[0]
+    
+    # Opportunity stats
+    cursor.execute("SELECT COUNT(*), COALESCE(SUM(value), 0) FROM opportunities")
+    row = cursor.fetchone()
+    stats["opportunities"] = {"count": row[0], "total_value": row[1]}
+    
+    conn.close()
+    return stats
+
+
+def get_leads_count_last_30_days() -> int:
+    """Get count of leads scraped in the last 30 days."""
+    conn = get_connection()
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT COUNT(*) FROM leads 
+        WHERE scraped_at >= datetime('now', '-30 days')
+    """)
+    count = cursor.fetchone()[0]
+    conn.close()
+    return count
+
+
+if __name__ == "__main__":
+    init_db()
+    stats = get_stats()
+    
+    print(f"\n[ESTADISTICAS] Estadísticas DOE:")
+    print(f"   Total leads: {stats['total_leads']}")
+    print(f"   Con email: {stats['with_email']}")
+    print(f"   Enriquecidos: {stats['enriched']}")
+    print(f"   WhatsApp enviados: {stats['whatsapp_sent']}")
+    print(f"   Emails enviados: {stats['email_sent']}")

lead_gen_pro/l3_execution/enrichment.py

@@ -0,0 +1,309 @@
+"""
+L3 Execution: Data Enrichment Module
+=====================================
+Enriquece leads con emails, teléfonos adicionales y perfiles sociales.
+Implementa la capa L3 del framework DOE.
+"""
+
+import os
+import re
+import json
+import time
+from typing import Optional, List, Dict, Any
+from urllib.parse import urlparse, quote
+
+# Optional: requests for web scraping
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+
+
+def extract_email_from_website(url: str, timeout: int = 10) -> Optional[str]:
+    """
+    Extract email from a website homepage.
+    
+    Args:
+        url: Website URL
+        timeout: Request timeout in seconds
+        
+    Returns:
+        First email found or None.
+    """
+    if not REQUESTS_AVAILABLE or not url:
+        return None
+    
+    try:
+        # Clean URL
+        if not url.startswith("http"):
+            url = f"https://{url}"
+        
+        response = requests.get(url, timeout=timeout, headers={
+            "User-Agent": "Mozilla/5.0 (compatible; LeadGen/1.0)"
+        })
+        
+        if response.status_code == 200:
+            # Email regex pattern
+            email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
+            emails = re.findall(email_pattern, response.text)
+            
+            # Filter out common non-business emails
+            excluded = ["example.com", "domain.com", "email.com", "test.com"]
+            for email in emails:
+                domain = email.split("@")[1].lower()
+                if domain not in excluded:
+                    return email.lower()
+        
+        return None
+        
+    except Exception as e:
+        print(f"  ⚠️ Error extrayendo email de {url}: {e}")
+        return None
+
+
+def extract_social_profiles(url: str, timeout: int = 10) -> Dict[str, Optional[str]]:
+    """
+    Extract social media profile links from website.
+    
+    Args:
+        url: Website URL
+        timeout: Request timeout
+        
+    Returns:
+        Dictionary with social profile URLs.
+    """
+    profiles = {
+        "facebook": None,
+        "instagram": None,
+        "linkedin": None,
+        "twitter": None,
+    }
+    
+    if not REQUESTS_AVAILABLE or not url:
+        return profiles
+    
+    try:
+        if not url.startswith("http"):
+            url = f"https://{url}"
+        
+        response = requests.get(url, timeout=timeout, headers={
+            "User-Agent": "Mozilla/5.0 (compatible; LeadGen/1.0)"
+        })
+        
+        if response.status_code == 200:
+            text = response.text
+            
+            # Facebook
+            fb_match = re.search(r'https?://(?:www\.)?facebook\.com/[a-zA-Z0-9._-]+', text)
+            if fb_match:
+                profiles["facebook"] = fb_match.group()
+            
+            # Instagram
+            ig_match = re.search(r'https?://(?:www\.)?instagram\.com/[a-zA-Z0-9._-]+', text)
+            if ig_match:
+                profiles["instagram"] = ig_match.group()
+            
+            # LinkedIn
+            li_match = re.search(r'https?://(?:www\.)?linkedin\.com/(?:in|company)/[a-zA-Z0-9._-]+', text)
+            if li_match:
+                profiles["linkedin"] = li_match.group()
+            
+            # Twitter/X
+            tw_match = re.search(r'https?://(?:www\.)?(?:twitter|x)\.com/[a-zA-Z0-9._-]+', text)
+            if tw_match:
+                profiles["twitter"] = tw_match.group()
+        
+    except Exception as e:
+        print(f"  ⚠️ Error extrayendo perfiles de {url}: {e}")
+    
+    return profiles
+
+
+def format_phone(phone: str, country: str = "usa") -> str:
+    """
+    Format phone number to international format.
+    """
+    if not phone:
+        return ""
+    
+    # Remove all non-numeric characters except +
+    cleaned = re.sub(r'[^\d+]', '', phone)
+    
+    # Add country code if missing
+    if not cleaned.startswith("+"):
+        if country == "usa":
+            if len(cleaned) == 10:
+                cleaned = f"+1{cleaned}"
+        elif country == "venezuela":
+            if len(cleaned) == 10: # local with area code
+                cleaned = f"+58{cleaned}"
+    
+    return cleaned
+
+
+def generate_whatsapp_link_raw(phone: str, message: str) -> str:
+    """Helper to generate WA link without importing the whole module."""
+    formatted_phone = "".join(c for c in phone if c.isdigit())
+    if formatted_phone.startswith("00"): formatted_phone = formatted_phone[2:]
+    return f"https://wa.me/{formatted_phone}?text={quote(message)}"
+
+def get_default_message(name: str, city: str, niche: str) -> str:
+    """Fast fallback message."""
+    return f"Hola {name}, vi tu negocio en {city}. Me gustaría hablar contigo."
+
+def clean_text(text: Optional[str]) -> Optional[str]:
+    """Clean text, normalize to Title Case and remove extra spaces."""
+    if not text:
+        return text
+    
+    # Remove extra spaces and normalize title case
+    cleaned = " ".join(text.split())
+    # Title cases but keeps acronyms if needed? Simple title() for now
+    return cleaned.title()
+
+
+def calculate_quality_score(lead: Dict[str, Any]) -> int:
+    """
+    Calculate a quality score from 0 to 100.
+    """
+    score = 0
+    weights = {
+        "email": 30,
+        "phone": 20,
+        "website": 15,
+        "social_profiles": 15,
+        "rating": 10,
+        "address": 10
+    }
+    
+    if lead.get("email"): score += weights["email"]
+    if lead.get("phone"): score += weights["phone"]
+    if lead.get("website"): score += weights["website"]
+    
+    social = lead.get("social_profiles", {})
+    social_count = sum(1 for v in social.values() if v)
+    if social_count > 0:
+        score += weights["social_profiles"] * (min(social_count, 3) / 3)
+        
+    if lead.get("rating"): score += weights["rating"]
+    if lead.get("address"): score += weights["address"]
+    
+    return int(score)
+
+
+def enrich_lead(lead: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Enrich a single lead with additional data and hygiene.
+    """
+    enriched = lead.copy()
+    
+    # 1. Hygiene: Normalize names and addresses
+    enriched["name"] = clean_text(lead.get("name"))
+    enriched["address"] = clean_text(lead.get("address"))
+    
+    print(f"  🔄 Enriqueciendo: {enriched.get('name', 'Unknown')}")
+    
+    # 2. Format phone
+    if lead.get("phone"):
+        enriched["phone_formatted"] = format_phone(
+            lead["phone"], 
+            lead.get("country", "usa")
+        )
+    
+    # 3. Extract email from website if not present
+    if not lead.get("email") and lead.get("website"):
+        email = extract_email_from_website(lead["website"])
+        if email:
+            enriched["email"] = email
+            print(f"    ✅ Email encontrado: {email}")
+    
+    # 4. Extract social profiles
+    if lead.get("website"):
+        profiles = extract_social_profiles(lead["website"])
+        enriched["social_profiles"] = profiles
+        
+        found = [k for k, v in profiles.items() if v]
+        if found:
+            print(f"    ✅ Perfiles sociales: {', '.join(found)}")
+            
+    # 5. WhatsApp Link Auto-generation
+    if enriched.get("phone_formatted"):
+        # Try to get template from config
+        from l3_execution.apify_scraper import get_config
+        config = get_config()
+        niche_cfg = config.get("niches", {}).get(lead.get("niche", "real_estate"), {})
+        template = niche_cfg.get("templates", {}).get("whatsapp", "Hola {name}")
+        
+        msg = template.format(
+            name=enriched.get("name", "there"),
+            city=enriched.get("city", "your area")
+        )
+        enriched["whatsapp_link"] = generate_whatsapp_link_raw(enriched["phone_formatted"], msg)
+
+    # 6. Quality Score
+    enriched["quality_score"] = calculate_quality_score(enriched)
+    
+    # Mark as enriched
+    enriched["enriched"] = True
+    
+    return enriched
+
+
+def enrich_leads(leads: List[Dict[str, Any]], delay: float = 1.0) -> List[Dict[str, Any]]:
+    """
+    Enrich a batch of leads.
+    
+    Args:
+        leads: List of lead dictionaries
+        delay: Delay between enrichments (seconds)
+        
+    Returns:
+        List of enriched leads.
+    """
+    print(f"\n🔍 Enriqueciendo {len(leads)} leads...\n")
+    
+    enriched_leads = []
+    
+    for i, lead in enumerate(leads):
+        enriched = enrich_lead(lead)
+        enriched_leads.append(enriched)
+        
+        if i < len(leads) - 1:
+            time.sleep(delay)
+    
+    # Stats
+    with_email = sum(1 for l in enriched_leads if l.get("email"))
+    with_social = sum(1 for l in enriched_leads if any(l.get("social_profiles", {}).values()))
+    
+    print(f"\n📊 Resultados del enriquecimiento:")
+    print(f"   - Con email: {with_email}/{len(enriched_leads)}")
+    print(f"   - Con perfiles sociales: {with_social}/{len(enriched_leads)}")
+    
+    return enriched_leads
+
+
+if __name__ == "__main__":
+    # Demo leads for testing
+    demo_leads = [
+        {
+            "name": "Miami Luxury Realty",
+            "phone": "786-555-0101",
+            "website": "https://www.rei.com",  # Using real site for demo
+            "country": "usa",
+        },
+        {
+            "name": "Test Business",
+            "phone": "212-555-0202",
+            "website": "https://example.com",
+            "country": "venezuela",
+        },
+    ]
+    
+    enriched = enrich_leads(demo_leads)
+    
+    print("\n📋 Leads enriquecidos:")
+    for lead in enriched:
+        print(f"  - {lead.get('name')}")
+        print(f"    📧 Email: {lead.get('email', 'N/A')}")
+        print(f"    📱 Phone: {lead.get('phone_formatted', lead.get('phone'))}")

lead_gen_pro/l3_execution/enrichment_pro.py

@@ -0,0 +1,34 @@
+"""
+L3 Execution: Pro Enrichment Pipeline
+====================================
+Integración con Apollo, Clearbit y Lusha (Simulada vía API calls).
+"""
+
+from typing import Dict, Any, List
+
+class ProEnrichment:
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config.get("enrichment", {})
+
+    def enrich_with_apollo(self, lead: Dict[str, Any]) -> Dict[str, Any]:
+        """Simula enriquecimiento con Apollo para emails/phones."""
+        if self.config.get("apollo_enabled") and lead.get("email"):
+            # Aquí iría la llamada real: requests.post("https://api.apollo.io/v1/...", ...)
+            lead["enrichment_source"] = "Apollo"
+            lead["verified_email"] = True
+            lead["direct_phone"] = lead.get("phone")  # Simulación
+        return lead
+
+    def enrich_with_clearbit(self, lead: Dict[str, Any]) -> Dict[str, Any]:
+        """Simula enriquecimiento con Clearbit para datos de empresa."""
+        if self.config.get("clearbit_enabled") and lead.get("company"):
+            lead["company_size"] = "50-200"
+            lead["company_revenue"] = "$10M+"
+            lead["industry_nicho"] = lead.get("niche")
+        return lead
+
+    def full_enrichment_flow(self, leads: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        for lead in leads:
+            lead = self.enrich_with_apollo(lead)
+            lead = self.enrich_with_clearbit(lead)
+        return leads

lead_gen_pro/l3_execution/instantly_sender.py

@@ -0,0 +1,260 @@
+"""
+L3 Execution: Instantly.ai Email Sender
+=========================================
+Envía emails profesionales usando la API de Instantly.ai.
+Implementa la capa L3 del framework DOE.
+"""
+
+import os
+import json
+import time
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+
+
+# Instantly API base URL
+INSTANTLY_API_BASE = "https://api.instantly.ai/api/v1"
+
+# Email templates by niche
+# Default templates (will be overriden by config.json)
+DEFAULT_TEMPLATES = {
+    "real_estate": {
+        "subject": "Quick question about {city} real estate",
+        "body": "Hi {name},\n\nI saw your work in {city}.\n\nBest,\n{sender_name}"
+    }
+}
+
+def get_config():
+    config_path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            return json.load(f)
+    return {}
+
+
+def get_instantly_api_key() -> Optional[str]:
+    """Get Instantly API key from environment or config."""
+    key = os.environ.get("INSTANTLY_API_KEY")
+    if key:
+        return key
+    
+    config_path = os.path.join(os.path.dirname(__file__), "..", "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            config = json.load(f)
+            return config.get("instantly_api_key")
+    
+    return None
+
+
+def format_email_template(
+    template_type: str,
+    lead: Dict[str, Any],
+    sender_name: str = "Your Name"
+) -> Dict[str, str]:
+    """
+    Format email template with lead data.
+    
+    Args:
+        template_type: 'real_estate' or 'insurance'
+        lead: Lead dictionary
+        sender_name: Name to sign emails with
+        
+    Returns:
+        Dictionary with 'subject' and 'body'.
+    """
+    config = get_config()
+    niche_config = config.get("niches", {}).get(template_type, {})
+    template = niche_config.get("templates", {}).get("email")
+    
+    if not template:
+        # Fallback to default
+        template = DEFAULT_TEMPLATES.get(template_type, DEFAULT_TEMPLATES["real_estate"])
+    
+    # Sign with config name if available
+    final_sender_name = config.get("sender", {}).get("name", sender_name)
+    
+    return {
+        "subject": template.get("subject", "Hello").format(
+            name=lead.get("name", "there"),
+            city=lead.get("city", "your area"),
+        ),
+        "body": template.get("body", "Hi").format(
+            name=lead.get("name", "there"),
+            city=lead.get("city", "your area"),
+            sender_name=final_sender_name,
+        )
+    }
+
+
+def send_email_instantly(
+    to_email: str,
+    subject: str,
+    body: str,
+    from_email: Optional[str] = None,
+    campaign_id: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Send email via Instantly.ai API.
+    
+    Args:
+        to_email: Recipient email address
+        subject: Email subject
+        body: Email body (plain text)
+        from_email: Sender email (optional)
+        campaign_id: Instantly campaign ID (optional)
+        
+    Returns:
+        API response or error dictionary.
+    """
+    api_key = get_instantly_api_key()
+    
+    if not api_key:
+        print("❌ INSTANTLY_API_KEY no configurado")
+        return {"success": False, "error": "API key missing", "mode": "demo"}
+    
+    if not REQUESTS_AVAILABLE:
+        return {"success": False, "error": "requests not available"}
+    
+    try:
+        # Instantly uses campaign-based sending
+        # For direct send, we need to add to a campaign or use transactional endpoint
+        
+        url = f"{INSTANTLY_API_BASE}/email/send"
+        
+        payload = {
+            "api_key": api_key,
+            "to": to_email,
+            "subject": subject,
+            "body": body,
+        }
+        
+        if from_email:
+            payload["from"] = from_email
+        if campaign_id:
+            payload["campaign_id"] = campaign_id
+        
+        response = requests.post(url, json=payload, timeout=30)
+        
+        if response.status_code == 200:
+            print(f"✅ Email enviado a {to_email}")
+            return {"success": True, "response": response.json()}
+        else:
+            print(f"❌ Error enviando email: {response.status_code}")
+            return {"success": False, "error": response.text}
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return {"success": False, "error": str(e)}
+
+
+def send_email_to_lead(
+    lead: Dict[str, Any],
+    sender_name: str = "Your Name"
+) -> Dict[str, Any]:
+    """
+    Send personalized email to a lead.
+    
+    Args:
+        lead: Lead dictionary with email
+        sender_name: Name to sign email with
+        
+    Returns:
+        Result dictionary.
+    """
+    email = lead.get("email")
+    if not email:
+        return {"success": False, "error": "No email address", "lead_id": lead.get("id")}
+    
+    niche = lead.get("niche", "real_estate")
+    formatted = format_email_template(niche, lead, sender_name)
+    
+    result = send_email_instantly(
+        to_email=email,
+        subject=formatted["subject"],
+        body=formatted["body"]
+    )
+    
+    result["lead_id"] = lead.get("id")
+    result["to_email"] = email
+    
+    return result
+
+
+def batch_send_emails(
+    leads: List[Dict[str, Any]],
+    sender_name: str = "Your Name",
+    delay_seconds: float = 30.0,
+    max_per_hour: int = 20
+) -> List[Dict[str, Any]]:
+    """
+    Send emails to a batch of leads with rate limiting.
+    
+    Args:
+        leads: List of leads with emails
+        sender_name: Name to sign emails
+        delay_seconds: Delay between emails
+        max_per_hour: Maximum emails per hour
+        
+    Returns:
+        List of results.
+    """
+    # Filter leads with emails
+    leads_with_email = [l for l in leads if l.get("email")]
+    
+    if not leads_with_email:
+        print("❌ No hay leads con email")
+        return []
+    
+    print(f"\n📧 Enviando {len(leads_with_email)} emails...")
+    
+    results = []
+    sent_count = 0
+    
+    for i, lead in enumerate(leads_with_email[:max_per_hour]):
+        result = send_email_to_lead(lead, sender_name)
+        results.append(result)
+        
+        if result.get("success"):
+            sent_count += 1
+        
+        # Rate limiting
+        if i < len(leads_with_email) - 1:
+            print(f"   ⏳ Esperando {delay_seconds}s...")
+            time.sleep(delay_seconds)
+    
+    print(f"\n📊 Emails enviados: {sent_count}/{len(leads_with_email)}")
+    return results
+
+
+def demo_email_preview(lead: Dict[str, Any], sender_name: str = "Your Name") -> None:
+    """Print email preview without sending."""
+    niche = lead.get("niche", "real_estate")
+    formatted = format_email_template(niche, lead, sender_name)
+    
+    print(f"\n{'='*50}")
+    print(f"📧 PREVIEW - Email para: {lead.get('email', 'N/A')}")
+    print(f"{'='*50}")
+    print(f"Subject: {formatted['subject']}")
+    print(f"\n{formatted['body']}")
+    print(f"{'='*50}\n")
+
+
+if __name__ == "__main__":
+    # Demo
+    demo_lead = {
+        "id": 1,
+        "name": "Miami Luxury Realty",
+        "email": "info@example.com",
+        "city": "Miami, FL",
+        "niche": "real_estate",
+    }
+    
+    print("🎭 Modo demo - Preview de email:")
+    demo_email_preview(demo_lead, sender_name="Test User")

lead_gen_pro/l3_execution/lead_scoring.py

@@ -0,0 +1,71 @@
+"""
+L3 Execution: Lead Scoring & Qualification (MQL/SQL)
+===================================================
+Modelo de scoring avanzado para calificar leads basados en datos firmográficos y geográficos.
+"""
+
+from typing import Dict, Any, List
+
+class LeadScorer:
+    def __init__(self):
+        # Configuración de regiones clave de USA
+        self.hot_regions = ["CA", "NY", "TX", "FL", "IL"]
+        self.priority_cities = ["San Francisco", "New York", "Austin", "Miami", "Chicago"]
+
+    def calculate_score(self, lead: Dict[str, Any]) -> Dict[str, Any]:
+        """Calcula el score de un lead de 0 a 100."""
+        score = 0
+        details = []
+
+        # 1. Scoring Geográfico (Max 30 pts)
+        # Obtener location y asegurar que sea string (manejar None)
+        location = lead.get("location") or ""
+        location = location.upper()
+        
+        # Obtener city y asegurar que sea string (manejar None)
+        city = lead.get("city") or ""
+        
+        if any(region in location for region in self.hot_regions):
+            score += 20
+            details.append("Region de alta prioridad (+20)")
+        if city and any(p_city in city for p_city in self.priority_cities):
+            score += 10
+            details.append("Ciudad estratégica (+10)")
+
+        # 2. Scoring de Contactabilidad (Max 40 pts)
+        if lead.get("email"):
+            score += 25
+            details.append("Email disponible (+25)")
+        if lead.get("phone"):
+            score += 15
+            details.append("Teléfono disponible (+15)")
+
+        # 3. Scoring de Relevancia (Max 30 pts)
+        niche = lead.get("niche", "").lower()
+        if niche in ["real_estate", "healthcare", "saas"]:
+            score += 20
+            details.append("Nicho premium (+20)")
+        
+        if lead.get("linkedin_url"):
+            score += 10
+            details.append("Enlace LinkedIn (+10)")
+
+        # Determinar Tier
+        if score >= 80:
+            tier = "SQL (Hot)"
+        elif score >= 40:
+            tier = "MQL (Warm)"
+        else:
+            tier = "Lead (Cold)"
+
+        return {
+            "score": score,
+            "tier": tier,
+            "score_details": ", ".join(details)
+        }
+
+    def process_batch(self, leads: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        for lead in leads:
+            scoring_data = self.calculate_score(lead)
+            lead.update(scoring_data)
+        return leads

lead_gen_pro/l3_execution/supabase_sync.py

@@ -0,0 +1,91 @@
+import requests
+import json
+from datetime import datetime
+
+# Supabase Configuration
+SUPABASE_URL = "https://nvssvykqxaurtlgwxwwy.supabase.co"
+SERVICE_ROLE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im52c3N2eWtxeGF1cnRsZ3d4d3d5Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc3Mjg5MjE2NSwiZXhwIjoyMDg4NDY4MTY1fQ.AceH8GESr9xKNmJBMHpM56HZASLRIjHc5dfxyLKBH_o"
+
+HEADERS = {
+    "apikey": SERVICE_ROLE_KEY,
+    "Authorization": f"Bearer {SERVICE_ROLE_KEY}",
+    "Content-Type": "application/json",
+    "Prefer": "resolution=merge-duplicates"
+}
+
+def sync_lead_to_supabase(lead_data):
+    """Syncs a single lead to Supabase 'leads' table."""
+    social = lead_data.get("social_profiles", {})
+    
+    # PG Table names (Spanish according to Notion findings)
+    payload = {
+        "nombre": lead_data.get("name") or "Sin nombre",
+        "telefono": lead_data.get("phone"),
+        "telefono_formateado": lead_data.get("phone_formatted"),
+        "correo": lead_data.get("email"),
+        "direccion": lead_data.get("address"),
+        "website": lead_data.get("website"),
+        "rating": lead_data.get("rating"),
+        "reviews_count": lead_data.get("reviews_count"),
+        "categoria": lead_data.get("category") or lead_data.get("niche"),
+        "fuente": lead_data.get("source") or "lead_gen_pro",
+        "nicho": lead_data.get("niche"),
+        "pais": lead_data.get("country"),
+        "ciudad": lead_data.get("city"),
+        "enriquecido": lead_data.get("enriched", False),
+        "estado": lead_data.get("status") or "nuevo",
+        "prioridad": lead_data.get("priority", 0),
+        "whatsapp_enviado": lead_data.get("whatsapp_sent", False),
+        "whatsapp_link": lead_data.get("whatsapp_link"),
+        "correo_enviado": lead_data.get("email_sent", False),
+        "es_oportunidad": lead_data.get("is_opportunity", False),
+        "valor_oportunidad": lead_data.get("opportunity_value"),
+        "notas_oportunidad": lead_data.get("opportunity_notes"),
+        "quality_score": lead_data.get("quality_score", 0),
+        "creado_en": lead_data.get("created_at") or datetime.now().isoformat(),
+        "actualizado_en": datetime.now().isoformat()
+    }
+
+    try:
+        response = requests.post(f"{SUPABASE_URL}/rest/v1/leads", headers=HEADERS, json=payload)
+        return response.status_code in [200, 201, 204]
+    except Exception as e:
+        print(f"[ERROR] Lead Sync Failed: {e}")
+        return False
+
+
+def sync_all_leads_to_supabase(db_path: str = None, limit: int = 500) -> dict:
+    """
+    Lee los leads más recientes de leads_doe.db y los sincroniza en batch a Supabase.
+    Útil para sincronización post-scraping masiva.
+    """
+    import sqlite3
+    import os
+
+    if db_path is None:
+        db_path = os.path.join(os.path.dirname(__file__), "..", "leads_doe.db")
+
+    if not os.path.exists(db_path):
+        return {"synced": 0, "errors": 0, "message": "DB not found"}
+
+    try:
+        conn = sqlite3.connect(db_path, timeout=10)
+        conn.row_factory = sqlite3.Row
+        cur = conn.cursor()
+        # Solo sincroniza leads que aún no han sido sincronizados (o los más recientes)
+        cur.execute(f"SELECT * FROM leads ORDER BY created_at DESC LIMIT {limit}")
+        rows = cur.fetchall()
+        conn.close()
+    except Exception as e:
+        return {"synced": 0, "errors": 0, "message": str(e)}
+
+    synced, errors = 0, 0
+    for row in rows:
+        lead_data = dict(row)
+        ok = sync_lead_to_supabase(lead_data)
+        if ok:
+            synced += 1
+        else:
+            errors += 1
+
+    return {"synced": synced, "errors": errors, "total": len(rows)}

lead_gen_pro/main.py

@@ -0,0 +1,97 @@
+"""
+Main Entry Point for Lead Generation System
+============================================
+Wrapper script that runs the DOE orchestrator.
+"""
+
+import os
+import sys
+
+# Ensure we're using the venv
+venv_path = os.path.join(os.path.dirname(__file__), "venv", "bin", "python")
+if os.path.exists(venv_path) and sys.executable != venv_path:
+    os.execv(venv_path, [venv_path] + sys.argv)
+
+# Add paths
+sys.path.insert(0, os.path.dirname(__file__))
+
+from l2_orchestration.orchestrator import (
+    run_full_pipeline,
+    run_scraping_only,
+    run_whatsapp_outreach,
+    run_email_outreach,
+    show_dashboard
+)
+from l3_execution.database_doe import init_db
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="🚀 Lead Generation DOE System",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Ejemplos:
+  python main.py --pipeline --niche real_estate --country usa --location "Miami, FL"
+  python main.py --scrape --niche insurance --country venezuela --location "Caracas"
+  python main.py --outreach-wa --limit 10
+  python main.py --dashboard
+  python main.py --streamlit
+        """
+    )
+    
+    # Actions
+    parser.add_argument("--pipeline", action="store_true", help="Ejecutar pipeline completo")
+    parser.add_argument("--scrape", action="store_true", help="Solo scraping de leads")
+    parser.add_argument("--outreach-wa", action="store_true", help="Generar links de WhatsApp")
+    parser.add_argument("--outreach-email", action="store_true", help="Preview/enviar emails")
+    parser.add_argument("--dashboard", action="store_true", help="Dashboard en texto")
+    parser.add_argument("--streamlit", action="store_true", help="Dashboard web Streamlit")
+    
+    # Options
+    parser.add_argument("--niche", choices=["real_estate", "insurance"], default="real_estate",
+                       help="Nicho objetivo (default: real_estate)")
+    parser.add_argument("--country", choices=["usa", "venezuela"], default="usa",
+                       help="País objetivo (default: usa)")
+    parser.add_argument("--limit", type=int, default=10, help="Límite de leads (default: 10)")
+    parser.add_argument("--location", type=str, help="Ubicación específica (Ciudad, Estado o ZIP)")
+    parser.add_argument("--demo", action="store_true", help="Modo demo sin API")
+    
+    args = parser.parse_args()
+    
+    # Initialize DB
+    init_db()
+    
+    # Execute action
+    if args.pipeline:
+        run_full_pipeline(
+            niche=args.niche,
+            country=args.country,
+            location=args.location,
+            limit_per_city=args.limit,
+            demo=args.demo
+        )
+    elif args.scrape:
+        run_scraping_only(
+            niche=args.niche,
+            country=args.country,
+            location=args.location,
+            limit=args.limit
+        )
+    elif args.outreach_wa:
+        run_whatsapp_outreach(limit=args.limit)
+    elif args.outreach_email:
+        run_email_outreach(limit=args.limit, preview_only=True)
+    elif args.dashboard:
+        show_dashboard()
+    elif args.streamlit:
+        import subprocess
+        dashboard_path = os.path.join(os.path.dirname(__file__), "dashboard", "app.py")
+        venv_streamlit = os.path.join(os.path.dirname(__file__), "venv", "bin", "streamlit")
+        subprocess.run([venv_streamlit, "run", dashboard_path, "--server.headless", "true"])
+    else:
+        # Show help if no action
+        parser.print_help()
+        print("\n📊 Estado actual:")
+        show_dashboard()

lead_gen_pro/main_pro.py

@@ -0,0 +1,264 @@
+"""
+Main Entry Point for Lead Generation PRO - COMPLETAMENTE COMENTADO
+===================================================================
+
+Este es el punto de entrada principal del sistema Lead Generation PRO.
+Funciona como una CLI (Command Line Interface) que permite ejecutar el 
+pipeline completo de generación de leads mediante argumentos de línea de comandos.
+
+AUTOR: Lead Generation PRO System
+FECHA: 2025
+VERSION: 2.0
+
+USO DESDE LÍNEA DE COMANDOS:
+    python3 main_pro.py --pipeline --niche "Insurance" --city "Miami" --state "FL" --country "USA"
+
+COMPONENTES PRINCIPALES:
+    - Parser de argumentos CLI (argparse)
+    - Inicialización de base de datos
+    - Delegación al ProOrchestrator para ejecución del pipeline
+
+FLUJO DE EJECUCIÓN:
+    1. Parsear argumentos de línea de comandos
+    2. Inicializar base de datos SQLite
+    3. Construir objeto de configuración con datos de ubicación
+    4. Llamar a ProOrchestrator.run_pro_pipeline()
+    5. Ejecutar scraping según tipo (B2B, B2C o ambos)
+"""
+
+# =============================================================================
+# IMPORTS
+# =============================================================================
+
+import os              # Para operaciones con sistema de archivos y variables de entorno
+import argparse        # Para parsear argumentos de línea de comandos
+
+# Importar el orquestador principal desde la capa L2
+# El orquestador coordina todo el flujo de trabajo
+from l2_orchestration.orchestrator_pro import ProOrchestrator
+
+# Importar función de inicialización de base de datos
+# Esta función crea las tablas necesarias si no existen
+from l3_execution.database_doe import init_db
+
+# =============================================================================
+# FUNCIÓN PRINCIPAL
+# =============================================================================
+
+def main():
+    """
+    Función principal que configura y ejecuta el pipeline de generación de leads.
+    
+    Esta función:
+    1. Define todos los argumentos CLI disponibles
+    2. Parsea los argumentos proporcionados por el usuario
+    3. Inicializa la base de datos
+    4. Ejecuta el pipeline según la configuración
+    """
+    
+    # -------------------------------------------------------------------------
+    # CONFIGURACIÓN DEL PARSER DE ARGUMENTOS
+    # -------------------------------------------------------------------------
+    
+    # Crear el parser con una descripción útil
+    parser = argparse.ArgumentParser(
+        description="Lead Generation PRO DOE System - Pipeline de generacion de leads B2B y B2C",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Ejemplos de uso:
+  # Buscar leads B2B de seguros en Miami
+  python3 main_pro.py --pipeline --niche "Insurance" --city "Miami" --state "FL" --type b2b
+  
+  # Buscar leads B2C en redes sociales
+  python3 main_pro.py --pipeline --niche "Real Estate" --city "Austin" --type b2c --b2c-platforms twitter facebook
+  
+  # Buscar ambos tipos con todas las plataformas
+  python3 main_pro.py --pipeline --niche "Healthcare" --country "USA" --type both --limit 50
+        """
+    )
+    
+    # -------------------------------------------------------------------------
+    # ARGUMENTOS PRINCIPALES
+    # -------------------------------------------------------------------------
+    
+    # --pipeline: Flag obligatorio para ejecutar el pipeline
+    parser.add_argument(
+        "--pipeline",
+        action="store_true",
+        help="Ejecutar Pipeline Pro (requerido para iniciar el scraping)"
+    )
+    
+    # --niche: Nicho o industria a buscar
+    parser.add_argument(
+        "--niche",
+        type=str,
+        default="Real Estate",
+        help="Nicho de mercado a buscar (ej: Real Estate, Insurance, Healthcare)"
+    )
+    
+    # --region: Región legacy (opcional, para compatibilidad hacia atrás)
+    parser.add_argument(
+        "--region",
+        type=str,
+        default="CA Bay Area",
+        help="Región legacy (opcional si se usa city/state/country)"
+    )
+    
+    # -------------------------------------------------------------------------
+    # ARGUMENTOS DE UBICACIÓN (GEO-TARGETING)
+    # -------------------------------------------------------------------------
+    
+    # --city: Ciudad objetivo
+    parser.add_argument(
+        "--city",
+        type=str,
+        help="Ciudad objetivo (ej: Miami, Austin, New York)"
+    )
+    
+    # --state: Estado o provincia
+    parser.add_argument(
+        "--state",
+        type=str,
+        help="Estado/Provincia (ej: FL, CA, TX)"
+    )
+    
+    # --country: País
+    parser.add_argument(
+        "--country",
+        type=str,
+        help="País (ej: USA, Canada, Mexico)"
+    )
+    
+    # -------------------------------------------------------------------------
+    # ARGUMENTO DE TIPO DE LEAD (B2B, B2C o AMBOS)
+    # -------------------------------------------------------------------------
+    
+    parser.add_argument(
+        "--type",
+        choices=["b2b", "b2c", "both"],
+        default="both",
+        help="""
+        Tipo de leads a buscar:
+        - b2b: Solo empresas y negocios (LinkedIn, Google Maps)
+        - b2c: Solo consumidores (Twitter, Reddit, YouTube, Facebook)
+        - both: Ambos tipos (por defecto)
+        """
+    )
+    
+    # -------------------------------------------------------------------------
+    # PLATAFORMAS B2B
+    # -------------------------------------------------------------------------
+    
+    parser.add_argument(
+        "--b2b-platforms",
+        nargs="+",  # Acepta uno o más valores
+        choices=["linkedin", "youtube", "tiktok", "instagram", "google_maps"],
+        default=["linkedin", "google_maps"],
+        help="""
+        Plataformas B2B a escanear:
+        - linkedin: Perfiles profesionales
+        - google_maps: Negocios locales
+        - youtube: Canales de YouTube
+        - tiktok: Cuentas por hashtags
+        - instagram: Perfiles por hashtags
+        """
+    )
+    
+    # -------------------------------------------------------------------------
+    # PLATAFORMAS B2C
+    # -------------------------------------------------------------------------
+    
+    parser.add_argument(
+        "--b2c-platforms",
+        nargs="+",
+        choices=["youtube", "reddit", "twitter", "facebook"],
+        default=["youtube", "reddit", "twitter"],
+        help="""
+        Plataformas B2C a escanear:
+        - youtube: Comentarios en videos
+        - reddit: Posts en subreddits
+        - twitter: Tweets públicos
+        - facebook: Posts públicos y grupos públicos
+        """
+    )
+    
+    # -------------------------------------------------------------------------
+    # ARGUMENTOS DE CONFIGURACIÓN
+    # -------------------------------------------------------------------------
+    
+    # --limit: Límite de leads por plataforma
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=20,
+        help="Límite de leads a obtener por cada plataforma (default: 20)"
+    )
+    
+    # -------------------------------------------------------------------------
+    # PARSEAR ARGUMENTOS
+    # -------------------------------------------------------------------------
+    
+    # Obtener los argumentos proporcionados por el usuario
+    args = parser.parse_args()
+    
+    # -------------------------------------------------------------------------
+    # INICIALIZACIÓN DE BASE DE DATOS
+    # -------------------------------------------------------------------------
+    
+    # Crear las tablas necesarias en SQLite si no existen
+    # Esto incluye: leads, outreach_log, opportunities, metrics
+    init_db()
+    
+    # -------------------------------------------------------------------------
+    # EJECUCIÓN DEL PIPELINE
+    # -------------------------------------------------------------------------
+    
+    # Verificar si se debe ejecutar el pipeline
+    if args.pipeline:
+        
+        # Construir diccionario de datos de ubicación
+        # Solo incluye los campos que fueron proporcionados
+        location_data = {}
+        if args.city:
+            location_data["city"] = args.city
+        if args.state:
+            location_data["state"] = args.state
+        if args.country:
+            location_data["country"] = args.country
+        
+        # Crear instancia del orquestador
+        # El orquestador coordina todo el flujo de trabajo
+        orchestrator = ProOrchestrator()
+        
+        # Ejecutar el pipeline principal
+        # Esta función hace todo el trabajo: scraping, scoring, deduplicación, almacenamiento
+        orchestrator.run_pro_pipeline(
+            niche=args.niche,                    # Nicho/industria a buscar
+            region=args.region,                  # Región legacy (para compatibilidad)
+            location_data=location_data,         # Datos de ubicación granular
+            lead_type=args.type,                 # Tipo: b2b, b2c, both
+            b2b_platforms=args.b2b_platforms,    # Lista de plataformas B2B
+            b2c_platforms=args.b2c_platforms,    # Lista de plataformas B2C
+            limit=args.limit                     # Límite por plataforma
+        )
+        
+    else:
+        # Si no se proporcionó --pipeline, mostrar la ayuda
+        parser.print_help()
+
+# =============================================================================
+# PUNTO DE ENTRADA
+# =============================================================================
+
+if __name__ == "__main__":
+    """
+    Punto de entrada estándar de Python.
+    
+    Este bloque se ejecuta solo cuando el archivo se ejecuta directamente
+    (no cuando se importa como módulo).
+    """
+    main()
+
+# =============================================================================
+# FIN DEL ARCHIVO
+# =============================================================================

lead_gen_pro/requirements.txt

@@ -0,0 +1,16 @@
+# Lead Generation System - Requirements
+# =====================================
+
+# Core
+requests>=2.31.0
+streamlit>=1.30.0
+pandas>=2.0.0
+plotly>=5.18.0
+apify-client>=1.6.0
+
+# WhatsApp & Automation
+playwright>=1.40.0
+
+# Utilities
+python-dotenv>=1.0.0
+schedule>=1.2.0

lead_gen_pro/scraper.py

@@ -0,0 +1,311 @@
+"""
+Google Maps Lead Scraper Module
+================================
+Uses SerpApi to search for business leads on Google Maps.
+Supports real estate agents and insurance brokers in USA and Venezuela.
+"""
+
+import os
+import json
+import time
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass
+
+# You'll need to install: pip install google-search-results
+try:
+    from serpapi import GoogleSearch
+    SERPAPI_AVAILABLE = True
+except ImportError:
+    SERPAPI_AVAILABLE = False
+    print("⚠️ SerpApi no está instalado. Ejecuta: pip install google-search-results")
+
+
+@dataclass
+class SearchConfig:
+    """Configuration for a lead search."""
+    query: str
+    location: str
+    country: str  # 'usa' or 'venezuela'
+    niche: str    # 'real_estate' or 'insurance'
+    limit: int = 20
+
+
+# Predefined search queries for each niche
+SEARCH_QUERIES = {
+    "real_estate": {
+        "usa": [
+            "real estate agent",
+            "realtor",
+            "real estate broker",
+            "property agent",
+        ],
+        "venezuela": [
+            "inmobiliaria",
+            "agente inmobiliario",
+            "bienes raices",
+            "corredor inmobiliario",
+        ]
+    },
+    "insurance": {
+        "usa": [
+            "insurance agent",
+            "insurance broker",
+            "insurance agency",
+            "life insurance agent",
+        ],
+        "venezuela": [
+            "corredor de seguros",
+            "agente de seguros",
+            "aseguradora",
+            "seguros de vida",
+        ]
+    }
+}
+
+# Major cities for each country
+CITIES = {
+    "usa": [
+        "Miami, FL",
+        "Houston, TX",
+        "Los Angeles, CA",
+        "New York, NY",
+        "Chicago, IL",
+        "Dallas, TX",
+        "Phoenix, AZ",
+        "Orlando, FL",
+    ],
+    "venezuela": [
+        "Caracas",
+        "Maracaibo",
+        "Valencia",
+        "Barquisimeto",
+        "Maracay",
+        "Puerto La Cruz",
+        "San Cristobal",
+    ]
+}
+
+
+def get_serpapi_key() -> Optional[str]:
+    """Get SerpApi key from environment or config file."""
+    # Try environment variable first
+    key = os.environ.get("SERPAPI_KEY")
+    if key:
+        return key
+    
+    # Try config file
+    config_path = os.path.join(os.path.dirname(__file__), "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            config = json.load(f)
+            return config.get("serpapi_key")
+    
+    return None
+
+
+def search_google_maps(
+    query: str,
+    location: str,
+    api_key: str,
+    limit: int = 20
+) -> List[Dict[str, Any]]:
+    """
+    Search Google Maps via SerpApi.
+    
+    Args:
+        query: Search query (e.g., "real estate agent")
+        location: Location string (e.g., "Miami, FL")
+        api_key: SerpApi API key
+        limit: Maximum number of results
+        
+    Returns:
+        List of business results with contact info.
+    """
+    if not SERPAPI_AVAILABLE:
+        print("❌ SerpApi no disponible. Instalando...")
+        return []
+    
+    results = []
+    
+    params = {
+        "engine": "google_maps",
+        "q": query,
+        "ll": None,  # Will be geocoded by location
+        "type": "search",
+        "api_key": api_key,
+    }
+    
+    # Add location to query
+    full_query = f"{query} in {location}"
+    params["q"] = full_query
+    
+    try:
+        search = GoogleSearch(params)
+        data = search.get_dict()
+        
+        places = data.get("local_results", [])
+        
+        for place in places[:limit]:
+            result = {
+                "name": place.get("title"),
+                "address": place.get("address"),
+                "phone": place.get("phone"),
+                "website": place.get("website"),
+                "rating": place.get("rating"),
+                "reviews_count": place.get("reviews"),
+                "place_id": place.get("place_id"),
+                "thumbnail": place.get("thumbnail"),
+            }
+            results.append(result)
+            
+    except Exception as e:
+        print(f"❌ Error en búsqueda: {e}")
+    
+    return results
+
+
+def scrape_leads(
+    niche: str,
+    country: str,
+    cities: Optional[List[str]] = None,
+    limit_per_city: int = 10
+) -> List[Dict[str, Any]]:
+    """
+    Scrape leads for a specific niche and country.
+    
+    Args:
+        niche: 'real_estate' or 'insurance'
+        country: 'usa' or 'venezuela'
+        cities: List of cities to search (uses defaults if None)
+        limit_per_city: Max leads per city
+        
+    Returns:
+        List of lead dictionaries ready for database insertion.
+    """
+    api_key = get_serpapi_key()
+    if not api_key:
+        print("❌ No se encontró SERPAPI_KEY. Configura la variable de entorno o config.json")
+        return []
+    
+    if cities is None:
+        cities = CITIES.get(country, [])[:3]  # Default to first 3 cities
+    
+    queries = SEARCH_QUERIES.get(niche, {}).get(country, [])
+    if not queries:
+        print(f"❌ No hay queries definidas para {niche}/{country}")
+        return []
+    
+    all_leads = []
+    seen_phones = set()  # Avoid duplicates
+    
+    for city in cities:
+        for query in queries[:2]:  # Use first 2 queries per city
+            print(f"🔍 Buscando: '{query}' en {city}...")
+            
+            results = search_google_maps(
+                query=query,
+                location=city,
+                api_key=api_key,
+                limit=limit_per_city
+            )
+            
+            for result in results:
+                phone = result.get("phone")
+                if phone and phone not in seen_phones:
+                    seen_phones.add(phone)
+                    
+                    lead = {
+                        "name": result.get("name"),
+                        "phone": phone,
+                        "email": None,  # Usually not available in Maps
+                        "address": result.get("address"),
+                        "website": result.get("website"),
+                        "rating": result.get("rating"),
+                        "reviews_count": result.get("reviews_count"),
+                        "source": "google_maps",
+                        "niche": niche,
+                        "country": country,
+                        "city": city,
+                    }
+                    all_leads.append(lead)
+            
+            # Rate limiting
+            time.sleep(1)
+    
+    print(f"✅ Total leads encontrados: {len(all_leads)}")
+    return all_leads
+
+
+def demo_mode() -> List[Dict[str, Any]]:
+    """
+    Return sample demo data without API calls.
+    Useful for testing the pipeline.
+    """
+    demo_leads = [
+        {
+            "name": "Miami Luxury Realty",
+            "phone": "+1-786-555-0101",
+            "email": None,
+            "address": "1234 Brickell Ave, Miami, FL",
+            "website": "https://example-realty.com",
+            "rating": 4.8,
+            "reviews_count": 127,
+            "source": "demo",
+            "niche": "real_estate",
+            "country": "usa",
+            "city": "Miami, FL",
+        },
+        {
+            "name": "Seguros Caracas Plus",
+            "phone": "+58-212-555-0202",
+            "email": None,
+            "address": "Av. Francisco de Miranda, Caracas",
+            "website": "https://example-seguros.com",
+            "rating": 4.5,
+            "reviews_count": 89,
+            "source": "demo",
+            "niche": "insurance",
+            "country": "venezuela",
+            "city": "Caracas",
+        },
+        {
+            "name": "Texas Home Experts",
+            "phone": "+1-713-555-0303",
+            "email": None,
+            "address": "5678 Westheimer Rd, Houston, TX",
+            "website": "https://example-homes.com",
+            "rating": 4.9,
+            "reviews_count": 215,
+            "source": "demo",
+            "niche": "real_estate",
+            "country": "usa",
+            "city": "Houston, TX",
+        },
+    ]
+    return demo_leads
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Google Maps Lead Scraper")
+    parser.add_argument("--niche", choices=["real_estate", "insurance"], default="real_estate")
+    parser.add_argument("--country", choices=["usa", "venezuela"], default="usa")
+    parser.add_argument("--demo", action="store_true", help="Use demo data instead of API")
+    parser.add_argument("--limit", type=int, default=5, help="Leads per city")
+    
+    args = parser.parse_args()
+    
+    if args.demo:
+        print("🎭 Modo demo activado")
+        leads = demo_mode()
+    else:
+        leads = scrape_leads(
+            niche=args.niche,
+            country=args.country,
+            limit_per_city=args.limit
+        )
+    
+    print(f"\n📋 Leads encontrados: {len(leads)}")
+    for lead in leads[:5]:
+        print(f"  - {lead['name']} | {lead['phone']} | {lead['city']}")

lead_gen_pro/whatsapp_sender.py

@@ -0,0 +1,267 @@
+"""
+WhatsApp Web Sender Module
+==========================
+Automates WhatsApp Web using Playwright for lead outreach.
+Includes rate limiting and human-like delays to avoid detection.
+"""
+
+import os
+import time
+import random
+import json
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+# Playwright is optional - will work in semi-manual mode without it
+try:
+    from playwright.sync_api import sync_playwright, Browser, Page
+    PLAYWRIGHT_AVAILABLE = True
+except ImportError:
+    PLAYWRIGHT_AVAILABLE = False
+    print("⚠️ Playwright no está instalado. Modo semi-automático disponible.")
+
+
+# Message templates for each niche
+# Default templates (will be overriden by config.json)
+DEFAULT_TEMPLATES = {
+    "real_estate": {
+        "usa": "Hi {name}! I saw your work in {city}. I have a proposal for you!",
+        "venezuela": "¡Hola {name}! Vi tu trabajo en {city}. ¡Tengo una propuesta!"
+    }
+}
+
+def get_config():
+    config_path = os.path.join(os.path.dirname(__file__), "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            return json.load(f)
+    return {}
+
+
+def get_random_delay(min_seconds: int = 5, max_seconds: int = 15) -> float:
+    """Get a random delay to simulate human behavior."""
+    return random.uniform(min_seconds, max_seconds)
+
+
+def format_phone_for_whatsapp(phone: str) -> str:
+    """
+    Format phone number for WhatsApp Web URL.
+    Removes all non-numeric characters except the leading +.
+    """
+    # Remove all non-numeric characters
+    cleaned = ''.join(c for c in phone if c.isdigit() or c == '+')
+    
+    # Remove leading + if present (WhatsApp API doesn't need it)
+    if cleaned.startswith('+'):
+        cleaned = cleaned[1:]
+    
+    return cleaned
+
+
+def get_message_for_lead(lead: Dict[str, Any]) -> str:
+    """
+    Get a personalized message for a lead based on their niche and country.
+    """
+    niche = lead.get("niche", "real_estate")
+    country = lead.get("country", "usa")
+    
+    config = get_config()
+    niche_config = config.get("niches", {}).get(niche, {})
+    template = niche_config.get("templates", {}).get("whatsapp")
+    
+    if not template:
+        template = DEFAULT_TEMPLATES.get(niche, {}).get(country, "Hello {name}")
+    
+    if isinstance(template, list):
+        template = random.choice(template)
+    
+    return template.format(
+        name=lead.get("name", "there"),
+        city=lead.get("city", "your area"),
+    )
+
+
+def generate_whatsapp_link(phone: str, message: str) -> str:
+    """
+    Generate a WhatsApp Web link for a given phone and message.
+    This can be opened manually or via automation.
+    """
+    from urllib.parse import quote
+    
+    formatted_phone = format_phone_for_whatsapp(phone)
+    encoded_message = quote(message)
+    
+    return f"https://wa.me/{formatted_phone}?text={encoded_message}"
+
+
+def send_whatsapp_message_manual(lead: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Generate a WhatsApp link for manual sending.
+    Returns the link and message for the user to send manually.
+    """
+    phone = lead.get("phone")
+    if not phone:
+        return {"success": False, "error": "No phone number"}
+    
+    message = get_message_for_lead(lead)
+    link = generate_whatsapp_link(phone, message)
+    
+    return {
+        "success": True,
+        "mode": "manual",
+        "phone": phone,
+        "message": message,
+        "link": link,
+        "lead_id": lead.get("id"),
+    }
+
+
+class WhatsAppWebAutomation:
+    """
+    Automates WhatsApp Web using Playwright.
+    Requires a logged-in WhatsApp Web session.
+    """
+    
+    def __init__(self, headless: bool = False):
+        self.headless = headless
+        self.browser: Optional[Browser] = None
+        self.page: Optional[Page] = None
+        self.session_dir = os.path.join(os.path.dirname(__file__), ".whatsapp_session")
+    
+    def start(self) -> bool:
+        """Start the browser and load WhatsApp Web."""
+        if not PLAYWRIGHT_AVAILABLE:
+            print("❌ Playwright no disponible. Usa el modo manual.")
+            return False
+        
+        try:
+            self.playwright = sync_playwright().start()
+            
+            # Use persistent context to keep login
+            self.browser = self.playwright.chromium.launch_persistent_context(
+                self.session_dir,
+                headless=self.headless,
+                args=["--start-maximized"]
+            )
+            
+            self.page = self.browser.pages[0] if self.browser.pages else self.browser.new_page()
+            self.page.goto("https://web.whatsapp.com")
+            
+            print("🟢 WhatsApp Web abierto. Esperando login...")
+            
+            # Wait for the main interface to load (indicates successful login)
+            self.page.wait_for_selector('[data-testid="chat-list"]', timeout=120000)
+            
+            print("✅ WhatsApp Web listo!")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error iniciando WhatsApp: {e}")
+            return False
+    
+    def send_message(self, phone: str, message: str) -> bool:
+        """
+        Send a message to a phone number.
+        Returns True if successful.
+        """
+        if not self.page:
+            print("❌ Navegador no iniciado")
+            return False
+        
+        try:
+            formatted_phone = format_phone_for_whatsapp(phone)
+            link = generate_whatsapp_link(formatted_phone, message)
+            
+            self.page.goto(link)
+            
+            # Wait for the send button
+            time.sleep(get_random_delay(3, 6))
+            
+            # Try to find and click the send button
+            send_button = self.page.query_selector('[data-testid="send"]')
+            if send_button:
+                time.sleep(get_random_delay(1, 3))
+                send_button.click()
+                print(f"✅ Mensaje enviado a {phone}")
+                return True
+            else:
+                print(f"⚠️ No se encontró botón de enviar para {phone}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error enviando mensaje a {phone}: {e}")
+            return False
+    
+    def stop(self):
+        """Close the browser."""
+        if self.browser:
+            self.browser.close()
+        if hasattr(self, 'playwright'):
+            self.playwright.stop()
+
+
+def batch_generate_links(leads: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Generate WhatsApp links for a batch of leads.
+    Returns a list of results with links for manual sending.
+    """
+    results = []
+    
+    for lead in leads:
+        result = send_whatsapp_message_manual(lead)
+        results.append(result)
+    
+    return results
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="WhatsApp Web Sender")
+    parser.add_argument("--demo", action="store_true", help="Generate demo links")
+    parser.add_argument("--auto", action="store_true", help="Use automated sending (requires Playwright)")
+    
+    args = parser.parse_args()
+    
+    # Demo leads for testing
+    demo_leads = [
+        {
+            "id": 1,
+            "name": "Miami Luxury Realty",
+            "phone": "+1-786-555-0101",
+            "niche": "real_estate",
+            "country": "usa",
+            "city": "Miami, FL",
+        },
+        {
+            "id": 2,
+            "name": "Seguros Caracas",
+            "phone": "+58-212-555-0202",
+            "niche": "insurance",
+            "country": "venezuela",
+            "city": "Caracas",
+        },
+    ]
+    
+    if args.demo:
+        print("🔗 Generando links de WhatsApp en modo demo...\n")
+        results = batch_generate_links(demo_leads)
+        
+        for r in results:
+            if r["success"]:
+                print(f"📱 {r['phone']}")
+                print(f"   Mensaje: {r['message'][:60]}...")
+                print(f"   Link: {r['link'][:80]}...\n")
+    
+    elif args.auto:
+        print("🤖 Modo automático (requiere Playwright instalado)")
+        wa = WhatsAppWebAutomation(headless=False)
+        if wa.start():
+            for lead in demo_leads:
+                message = get_message_for_lead(lead)
+                wa.send_message(lead["phone"], message)
+                time.sleep(get_random_delay(20, 40))  # Long delay between messages
+            wa.stop()
+    
+    else:
+        print("Usa --demo para generar links o --auto para envío automático")

lead_gen_pro/workflow.py

@@ -0,0 +1,230 @@
+"""
+Lead Generation Workflow Orchestrator
+======================================
+Main entry point that orchestrates the entire lead generation pipeline:
+1. Scrape leads from Google Maps
+2. Store leads in database
+3. Generate outreach messages
+4. Track outreach status
+"""
+
+import os
+import sys
+import time
+import json
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+# Import local modules
+from database import init_db, add_lead, get_leads, get_pending_outreach, mark_outreach_sent, get_stats
+from scraper import scrape_leads, demo_mode as scraper_demo
+from whatsapp_sender import batch_generate_links, send_whatsapp_message_manual
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from config.json."""
+    config_path = os.path.join(os.path.dirname(__file__), "config.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            return json.load(f)
+    return {}
+
+
+def run_scraping_pipeline(
+    niche: str,
+    country: str,
+    limit_per_city: int = 5,
+    demo: bool = False
+) -> int:
+    """
+    Run the scraping pipeline for a specific niche and country.
+    
+    Args:
+        niche: 'real_estate' or 'insurance'
+        country: 'usa' or 'venezuela'
+        limit_per_city: Max leads per city
+        demo: Use demo data instead of API
+        
+    Returns:
+        Number of leads added to database.
+    """
+    print(f"\n{'='*50}")
+    print(f"🔍 SCRAPING: {niche.upper()} en {country.upper()}")
+    print(f"{'='*50}\n")
+    
+    if demo:
+        leads = scraper_demo()
+        # Filter demo leads by niche/country
+        leads = [l for l in leads if l.get("niche") == niche and l.get("country") == country]
+    else:
+        leads = scrape_leads(
+            niche=niche,
+            country=country,
+            limit_per_city=limit_per_city
+        )
+    
+    # Add leads to database
+    added_count = 0
+    for lead in leads:
+        try:
+            lead_id = add_lead(lead)
+            added_count += 1
+            print(f"  ✅ Agregado: {lead['name']} (ID: {lead_id})")
+        except Exception as e:
+            print(f"  ⚠️ Error agregando lead: {e}")
+    
+    print(f"\n📊 Total leads agregados: {added_count}")
+    return added_count
+
+
+def run_outreach_pipeline(
+    niche: Optional[str] = None,
+    channel: str = "whatsapp",
+    limit: int = 10,
+    auto_send: bool = False
+) -> List[Dict[str, Any]]:
+    """
+    Run the outreach pipeline for pending leads.
+    
+    Args:
+        niche: Filter by niche (optional)
+        channel: 'whatsapp' or 'instagram'
+        limit: Max leads to process
+        auto_send: If True, attempt automatic sending (requires Playwright)
+        
+    Returns:
+        List of outreach results.
+    """
+    print(f"\n{'='*50}")
+    print(f"📤 OUTREACH: {channel.upper()} ({limit} leads)")
+    print(f"{'='*50}\n")
+    
+    # Get pending leads
+    leads = get_pending_outreach(channel=channel, niche=niche, limit=limit)
+    
+    if not leads:
+        print("✅ No hay leads pendientes de contactar.")
+        return []
+    
+    print(f"📋 {len(leads)} leads pendientes encontrados\n")
+    
+    results = []
+    
+    if channel == "whatsapp":
+        # Generate WhatsApp links
+        link_results = batch_generate_links(leads)
+        
+        for i, result in enumerate(link_results):
+            if result["success"]:
+                lead = leads[i]
+                print(f"📱 Lead #{lead.get('id', i)}: {lead.get('name', 'Unknown')}")
+                print(f"   Teléfono: {result['phone']}")
+                print(f"   Mensaje: {result['message'][:50]}...")
+                print(f"   🔗 Link: {result['link'][:60]}...\n")
+                
+                # Mark as sent if in auto mode
+                if auto_send:
+                    # TODO: Implement actual sending with Playwright
+                    pass
+                
+                results.append(result)
+    
+    return results
+
+
+def print_dashboard():
+    """Print a dashboard with current stats."""
+    stats = get_stats()
+    
+    print(f"\n{'='*50}")
+    print(f"📊 DASHBOARD - Lead Generation System")
+    print(f"{'='*50}")
+    print(f"\n📈 Total de Leads: {stats['total_leads']}")
+    
+    if stats['by_niche']:
+        print("\n🏷️ Por Nicho:")
+        for niche, count in stats['by_niche'].items():
+            print(f"   - {niche}: {count}")
+    
+    if stats['by_country']:
+        print("\n🌎 Por País:")
+        for country, count in stats['by_country'].items():
+            print(f"   - {country}: {count}")
+    
+    if stats['by_status']:
+        print("\n📌 Por Estado:")
+        for status, count in stats['by_status'].items():
+            print(f"   - {status}: {count}")
+    
+    print(f"\n📤 Outreach Enviado:")
+    print(f"   - WhatsApp: {stats['whatsapp_sent']}")
+    print(f"   - Instagram: {stats['instagram_sent']}")
+    print(f"\n{'='*50}\n")
+
+
+def full_pipeline_demo():
+    """Run a full demo of the entire pipeline."""
+    print("\n🚀 INICIANDO PIPELINE COMPLETO EN MODO DEMO\n")
+    
+    # Initialize database
+    print("1️⃣ Inicializando base de datos...")
+    init_db()
+    
+    # Scrape demo leads for all combinations
+    combinations = [
+        ("real_estate", "usa"),
+        ("real_estate", "venezuela"),
+        ("insurance", "usa"),
+        ("insurance", "venezuela"),
+    ]
+    
+    print("\n2️⃣ Scraping de leads (modo demo)...")
+    for niche, country in combinations:
+        run_scraping_pipeline(niche=niche, country=country, demo=True)
+    
+    # Show dashboard
+    print("\n3️⃣ Estado actual del sistema:")
+    print_dashboard()
+    
+    # Generate outreach links
+    print("\n4️⃣ Generando links de WhatsApp para outreach...")
+    results = run_outreach_pipeline(channel="whatsapp", limit=5)
+    
+    print(f"\n✅ Pipeline demo completado. {len(results)} links generados.")
+    return results
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Lead Generation Workflow")
+    parser.add_argument("--demo", action="store_true", help="Run full demo pipeline")
+    parser.add_argument("--scrape", action="store_true", help="Run scraping only")
+    parser.add_argument("--outreach", action="store_true", help="Run outreach only")
+    parser.add_argument("--stats", action="store_true", help="Show dashboard only")
+    parser.add_argument("--niche", choices=["real_estate", "insurance"], default="real_estate")
+    parser.add_argument("--country", choices=["usa", "venezuela"], default="usa")
+    parser.add_argument("--limit", type=int, default=10)
+    
+    args = parser.parse_args()
+    
+    if args.demo:
+        full_pipeline_demo()
+    elif args.scrape:
+        init_db()
+        run_scraping_pipeline(
+            niche=args.niche,
+            country=args.country,
+            limit_per_city=args.limit,
+            demo=True  # Change to False when SerpApi is configured
+        )
+    elif args.outreach:
+        run_outreach_pipeline(niche=args.niche, limit=args.limit)
+    elif args.stats:
+        init_db()
+        print_dashboard()
+    else:
+        print("Usa --demo para ejecutar el pipeline completo en modo demo")
+        print("Usa --scrape para ejecutar solo el scraping")
+        print("Usa --outreach para ejecutar solo el outreach")
+        print("Usa --stats para ver las estadísticas")

index.html → static/index.html

@@ -1,216 +1,595 @@
 <!DOCTYPE html>
 <html lang="es">
+
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>NexusCRM - CRM + Lead Gen</title>
     <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        
+        :root {
+            --primary: #6366f1;
+            --primary-glow: rgba(99, 102, 241, 0.5);
+            --secondary: #a855f7;
+            --bg-dark: #0f172a;
+            --glass-bg: rgba(255, 255, 255, 0.05);
+            --glass-border: rgba(255, 255, 255, 0.1);
+            --text-main: #f8fafc;
+            --text-dim: #94a3b8;
+            --success: #22c55e;
+            --warning: #f59e0b;
+            --danger: #ef4444;
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
         body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-            background: #f5f5f5;
+            font-family: 'Inter', -apple-system, system-ui, sans-serif;
+            background: var(--bg-dark);
+            background-image:
+                radial-gradient(at 0% 0%, rgba(99, 102, 241, 0.15) 0, transparent 50%),
+                radial-gradient(at 100% 100%, rgba(168, 85, 247, 0.15) 0, transparent 50%);
+            color: var(--text-main);
             min-height: 100vh;
+            overflow-x: hidden;
         }
-        
+
         .header {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            background: rgba(15, 23, 42, 0.8);
+            backdrop-filter: blur(12px);
+            border-bottom: 1px solid var(--glass-border);
             color: white;
-            padding: 1rem 2rem;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            padding: 1.5rem 2rem;
+            position: sticky;
+            top: 0;
+            z-index: 100;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .header h1 {
+            font-size: 1.75rem;
+            font-weight: 800;
+            background: linear-gradient(to right, #818cf8, #c084fc);
+            -webkit-background-clip: text;
+            background-clip: text;
+            -webkit-text-fill-color: transparent;
+            letter-spacing: -0.025em;
+        }
+
+        .header .subtitle {
+            font-size: 0.875rem;
+            color: var(--text-dim);
+            font-weight: 500;
         }
-        
-        .header h1 { font-size: 1.5rem; }
-        .header .subtitle { font-size: 0.875rem; opacity: 0.9; }
-        
+
         .nav {
-            background: white;
-            padding: 0.5rem 2rem;
-            border-bottom: 1px solid #e0e0e0;
+            padding: 1rem 2rem;
             display: flex;
-            gap: 0.5rem;
+            gap: 0.75rem;
             flex-wrap: wrap;
         }
-        
+
         .nav button {
-            padding: 0.5rem 1rem;
-            border: none;
-            background: transparent;
+            padding: 0.6rem 1.25rem;
+            border: 1px solid var(--glass-border);
+            background: var(--glass-bg);
+            backdrop-filter: blur(4px);
+            color: var(--text-main);
             cursor: pointer;
             font-size: 0.9rem;
-            border-radius: 4px;
-            transition: all 0.2s;
+            font-weight: 600;
+            border-radius: 9999px;
+            transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
         }
-        
-        .nav button:hover { background: #f0f0f0; }
-        
+
+        .nav button:hover {
+            background: rgba(255, 255, 255, 0.1);
+            border-color: rgba(255, 255, 255, 0.2);
+            transform: translateY(-1px);
+        }
+
         .nav button.active {
-            background: #667eea;
-            color: white;
+            background: var(--primary);
+            border-color: var(--primary);
+            box-shadow: 0 0 20px var(--primary-glow);
+        }
+
+        .main {
+            padding: 0 2rem 2rem 2rem;
         }
-        
-        .main { padding: 1.5rem; }
-        
+
         .stats {
             display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
-            gap: 1rem;
-            margin-bottom: 1.5rem;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 1.5rem;
+            margin-bottom: 2rem;
         }
-        
+
         .stat-card {
-            background: white;
-            padding: 1.25rem;
-            border-radius: 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-        
-        .stat-card h3 { color: #666; font-size: 0.8rem; margin-bottom: 0.5rem; text-transform: uppercase; }
-        .stat-card .value { font-size: 1.75rem; font-weight: bold; color: #667eea; }
-        .stat-card .value.green { color: #4caf50; }
-        .stat-card .value.orange { color: #f57c00; }
-        .stat-card .value.red { color: #f44336; }
-        
-        .card {
-            background: white;
+            background: var(--glass-bg);
+            backdrop-filter: blur(20px);
             padding: 1.5rem;
-            border-radius: 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-            margin-bottom: 1rem;
+            border-radius: 16px;
+            border: 1px solid var(--glass-border);
+            transition: transform 0.3s ease;
+        }
+
+        .stat-card:hover {
+            transform: translateY(-4px);
+        }
+
+        .stat-card h3 {
+            color: var(--text-dim);
+            font-size: 0.75rem;
+            margin-bottom: 0.75rem;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+
+        .stat-card .value {
+            font-size: 2.25rem;
+            font-weight: 800;
+            color: white;
+        }
+
+        .stat-card .value.green {
+            color: var(--success);
         }
-        
-        .card h2 { margin-bottom: 1rem; color: #333; font-size: 1.25rem; }
-        
+
+        .stat-card .value.orange {
+            color: var(--warning);
+        }
+
+        .card {
+            background: var(--glass-bg);
+            backdrop-filter: blur(20px);
+            padding: 2rem;
+            border-radius: 20px;
+            border: 1px solid var(--glass-border);
+            margin-bottom: 2rem;
+        }
+
+        .card h2 {
+            margin-bottom: 1.5rem;
+            color: white;
+            font-size: 1.5rem;
+            font-weight: 700;
+        }
+
         .filters {
             display: flex;
             gap: 1rem;
-            margin-bottom: 1rem;
+            margin-bottom: 1.5rem;
             flex-wrap: wrap;
         }
-        
-        .filters select, .filters input {
-            padding: 0.5rem;
-            border: 1px solid #e0e0e0;
-            border-radius: 4px;
+
+        .filters select,
+        .filters input {
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid var(--glass-border);
+            padding: 0.75rem 1rem;
+            border-radius: 12px;
+            color: white;
             font-size: 0.9rem;
+            outline: none;
+            transition: border-color 0.2s;
         }
-        
-        .filters input[type="text"] { flex: 1; min-width: 200px; }
-        
+
+        .filters select:focus,
+        .filters input:focus {
+            border-color: var(--primary);
+        }
+
+        .filters input[type="text"] {
+            flex: 1;
+            min-width: 280px;
+        }
+
+        .filters select option {
+            background: var(--bg-dark);
+        }
+
         table {
             width: 100%;
-            border-collapse: collapse;
+            border-collapse: separate;
+            border-spacing: 0 0.5rem;
         }
-        
-        th, td {
-            padding: 0.75rem;
+
+        th {
+            padding: 1rem;
             text-align: left;
-            border-bottom: 1px solid #e0e0e0;
-            font-size: 0.9rem;
+            font-size: 0.75rem;
+            text-transform: uppercase;
+            color: var(--text-dim);
+            letter-spacing: 0.05em;
+            font-weight: 600;
+        }
+
+        td {
+            padding: 1rem;
+            background: rgba(255, 255, 255, 0.02);
+            border-top: 1px solid var(--glass-border);
+            border-bottom: 1px solid var(--glass-border);
+            font-size: 0.95rem;
+        }
+
+        td:first-child {
+            border-left: 1px solid var(--glass-border);
+            border-radius: 12px 0 0 12px;
         }
-        
-        th { background: #f9f9f9; font-weight: 600; color: #555; }
-        tr:hover { background: #f5f5f5; }
-        
+
+        td:last-child {
+            border-right: 1px solid var(--glass-border);
+            border-radius: 0 12px 12px 0;
+        }
+
+        tr:hover td {
+            background: rgba(255, 255, 255, 0.05);
+        }
+
         .badge {
-            display: inline-block;
-            padding: 0.2rem 0.5rem;
-            border-radius: 4px;
+            padding: 0.35rem 0.75rem;
+            border-radius: 9999px;
+            font-size: 0.7rem;
+            font-weight: 700;
+            text-transform: uppercase;
+        }
+
+        .badge-lead {
+            background: rgba(99, 102, 241, 0.1);
+            color: #818cf8;
+            border: 1px solid rgba(99, 102, 241, 0.2);
+        }
+
+        .badge-cliente {
+            background: rgba(34, 197, 94, 0.1);
+            color: #4ade80;
+            border: 1px solid rgba(34, 197, 94, 0.2);
+        }
+
+        .badge-nuevo {
+            background: rgba(245, 158, 11, 0.1);
+            color: #fbbf24;
+            border: 1px solid rgba(245, 158, 11, 0.2);
+        }
+
+        .badge-contactado {
+            background: rgba(14, 165, 233, 0.1);
+            color: #38bdf8;
+            border: 1px solid rgba(14, 165, 233, 0.2);
+        }
+
+        .badge-ganado {
+            background: rgba(34, 197, 94, 0.1);
+            color: #4ade80;
+        }
+
+        .quality-ring {
+            display: inline-flex;
+            width: 32px;
+            height: 32px;
+            border-radius: 50%;
+            align-items: center;
+            justify-content: center;
+            font-weight: 800;
             font-size: 0.75rem;
-            font-weight: 600;
+            border: 2px solid;
+        }
+
+        .q-high {
+            color: var(--success);
+            border-color: var(--success);
+            background: rgba(34, 197, 94, 0.1);
+        }
+
+        .q-med {
+            color: var(--warning);
+            border-color: var(--warning);
+            background: rgba(245, 158, 11, 0.1);
         }
-        
-        .badge-lead { background: #e3f2fd; color: #1976d2; }
-        .badge-cliente { background: #e8f5e9; color: #388e3c; }
-        .badge-nuevo { background: #fff3e0; color: #f57c00; }
-        .badge-contactado { background: #e1f5fe; color: #0288d1; }
-        .badge-calificado { background: #f3e5f5; color: #7b1fa2; }
-        .badge-ganado { background: #e8f5e9; color: #2e7d32; }
-        .badge-perdido { background: #ffebee; color: #c62828; }
-        
+
+        .q-low {
+            color: var(--danger);
+            border-color: var(--danger);
+            background: rgba(239, 68, 68, 0.1);
+        }
+
         .btn {
-            padding: 0.4rem 0.75rem;
-            border: none;
-            border-radius: 4px;
+            padding: 0.6rem 1rem;
+            border-radius: 10px;
+            font-weight: 600;
             cursor: pointer;
-            font-size: 0.8rem;
             transition: all 0.2s;
+            border: none;
+            display: inline-flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .btn-primary {
+            background: var(--primary);
+            color: white;
+        }
+
+        .btn-whatsapp {
+            background: #25d366;
+            color: white;
+            text-decoration: none;
         }
-        
-        .btn-primary { background: #667eea; color: white; }
-        .btn-primary:hover { background: #5a6fd6; }
-        .btn-success { background: #4caf50; color: white; }
-        .btn-success:hover { background: #43a047; }
-        .btn-whatsapp { background: #25d366; color: white; }
-        .btn-whatsapp:hover { background: #20b655; }
-        
+
+        .btn:active {
+            transform: scale(0.95);
+        }
+
         .pipeline-stages {
             display: flex;
-            gap: 1rem;
+            gap: 1.5rem;
             overflow-x: auto;
             padding-bottom: 1rem;
         }
-        
+
         .pipeline-stage {
-            min-width: 250px;
-            background: #f9f9f9;
-            border-radius: 8px;
-            padding: 1rem;
+            min-width: 280px;
+            background: rgba(255, 255, 255, 0.02);
+            border-radius: 20px;
+            padding: 1.25rem;
+            border: 1px solid var(--glass-border);
         }
-        
+
         .pipeline-stage h4 {
-            color: #555;
-            margin-bottom: 0.75rem;
-            padding-bottom: 0.5rem;
-            border-bottom: 2px solid #ddd;
+            color: white;
+            margin-bottom: 1rem;
+            display: flex;
+            justify-content: space-between;
         }
-        
+
         .pipeline-item {
-            background: white;
-            padding: 0.75rem;
+            background: rgba(255, 255, 255, 0.05);
+            padding: 1rem;
+            border-radius: 12px;
+            margin-bottom: 0.75rem;
+            border: 1px solid var(--glass-border);
+            cursor: pointer;
+        }
+
+        .pipeline-item:hover {
+            border-color: var(--primary);
+        }
+
+        #recent-leads table tr td:last-child {
+            text-align: right;
+        }
+
+        ::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        ::-webkit-scrollbar-track {
+            background: var(--bg-dark);
+        }
+
+        ::-webkit-scrollbar-thumb {
+            background: var(--glass-border);
             border-radius: 4px;
-            margin-bottom: 0.5rem;
-            box-shadow: 0 1px 2px rgba(0,0,0,0.1);
-        }
-        
-        .pipeline-item .name { font-weight: 600; font-size: 0.9rem; }
-        .pipeline-item .value { color: #4caf50; font-weight: 600; }
-        .pipeline-item .meta { font-size: 0.75rem; color: #888; }
-        
-        .form-group { margin-bottom: 1rem; }
-        .form-group label { display: block; margin-bottom: 0.5rem; font-weight: 500; font-size: 0.9rem; }
-        .form-group input, .form-group select, .form-group textarea {
+        }
+
+        ::-webkit-scrollbar-thumb:hover {
+            background: var(--text-dim);
+        }
+
+        /* ─── Lead Gen Tab ─────────────────────────── */
+        .leadgen-grid {
+            display: grid;
+            grid-template-columns: 380px 1fr;
+            gap: 1.5rem;
+            align-items: start;
+        }
+
+        .leadgen-form-card {
+            background: var(--glass-bg);
+            border: 1px solid var(--glass-border);
+            border-radius: 16px;
+            padding: 1.75rem;
+            backdrop-filter: blur(8px);
+        }
+
+        .leadgen-form-card h3 {
+            font-size: 1rem;
+            font-weight: 700;
+            margin-bottom: 1.25rem;
+            color: #818cf8;
+            text-transform: uppercase;
+            letter-spacing: 0.08em;
+        }
+
+        .form-row {
+            margin-bottom: 0.9rem;
+        }
+
+        .form-row label {
+            display: block;
+            font-size: 0.75rem;
+            font-weight: 600;
+            color: var(--text-dim);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            margin-bottom: 0.4rem;
+        }
+
+        .form-row select,
+        .form-row input[type=number],
+        .form-row input[type=text] {
             width: 100%;
-            padding: 0.6rem;
-            border: 1px solid #e0e0e0;
-            border-radius: 4px;
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid var(--glass-border);
+            border-radius: 10px;
+            color: var(--text-main);
+            padding: 0.6rem 0.9rem;
             font-size: 0.9rem;
+            outline: none;
+            transition: border-color 0.2s;
         }
-        
-        .grid-2 { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; }
-        
-        .whatsapp-card {
-            background: #f0fdf4;
-            border: 1px solid #bbf7d0;
-            padding: 1rem;
+
+        .form-row select:focus,
+        .form-row input:focus {
+            border-color: var(--primary);
+        }
+
+        .platform-grid {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 0.4rem;
+            margin-top: 0.4rem;
+        }
+
+        .platform-check {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            font-size: 0.85rem;
+            cursor: pointer;
+            padding: 0.4rem 0.5rem;
             border-radius: 8px;
-            margin-bottom: 1rem;
+            transition: background 0.15s;
+        }
+
+        .platform-check:hover {
+            background: rgba(255, 255, 255, 0.06);
+        }
+
+        .platform-check input {
+            accent-color: var(--primary);
+        }
+
+        .btn-run {
+            width: 100%;
+            padding: 0.9rem;
+            background: linear-gradient(135deg, var(--primary), var(--secondary));
+            border: none;
+            border-radius: 12px;
+            color: white;
+            font-weight: 700;
+            font-size: 1rem;
+            cursor: pointer;
+            margin-top: 1rem;
+            transition: opacity 0.2s, transform 0.15s;
+            letter-spacing: 0.03em;
+        }
+
+        .btn-run:hover {
+            opacity: 0.9;
+            transform: translateY(-1px);
+        }
+
+        .btn-run:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .log-terminal {
+            background: #0a0f1e;
+            border: 1px solid rgba(99, 102, 241, 0.3);
+            border-radius: 12px;
+            padding: 1rem;
+            height: 280px;
+            overflow-y: auto;
+            font-family: 'Courier New', monospace;
+            font-size: 0.78rem;
+            color: #4ade80;
+            line-height: 1.5;
+            white-space: pre-wrap;
+            word-break: break-all;
+        }
+
+        .log-terminal .log-err {
+            color: #f87171;
+        }
+
+        .log-terminal .log-done {
+            color: #818cf8;
+            font-weight: 700;
+        }
+
+        .server-banner {
+            background: rgba(245, 158, 11, 0.1);
+            border: 1px solid rgba(245, 158, 11, 0.3);
+            border-radius: 12px;
+            padding: 1rem 1.25rem;
+            margin-bottom: 1.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+            font-size: 0.88rem;
+        }
+
+        .server-banner.online {
+            background: rgba(34, 197, 94, 0.1);
+            border-color: rgba(34, 197, 94, 0.3);
+            color: #4ade80;
+        }
+
+        .server-banner.offline {
+            color: #fbbf24;
+        }
+
+        .lg-stat-row {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr);
+            gap: 1rem;
+            margin-bottom: 1.5rem;
+        }
+
+        .lg-stat {
+            background: var(--glass-bg);
+            border: 1px solid var(--glass-border);
+            border-radius: 12px;
+            padding: 1rem;
+            text-align: center;
+        }
+
+        .lg-stat .val {
+            font-size: 1.75rem;
+            font-weight: 800;
+            color: #818cf8;
+        }
+
+        .lg-stat .lbl {
+            font-size: 0.7rem;
+            color: var(--text-dim);
+            text-transform: uppercase;
+            margin-top: 0.2rem;
+        }
+
+        .btn-sync {
+            padding: 0.6rem 1.2rem;
+            background: rgba(99, 102, 241, 0.15);
+            border: 1px solid rgba(99, 102, 241, 0.4);
+            border-radius: 10px;
+            color: #818cf8;
+            font-weight: 600;
+            font-size: 0.85rem;
+            cursor: pointer;
+            transition: background 0.2s;
+        }
+
+        .btn-sync:hover {
+            background: rgba(99, 102, 241, 0.3);
         }
-        
-        .whatsapp-card .phone { font-size: 1.1rem; font-weight: 600; color: #166534; }
-        .whatsapp-card .name { color: #166534; }
-        
-        .loading { text-align: center; padding: 2rem; color: #666; }
-        
-        .action-buttons { display: flex; gap: 0.5rem; }
     </style>
 </head>
+
 <body>
     <div class="header">
         <h1>NexusCRM</h1>
         <div class="subtitle">CRM + Lead Gen Pro</div>
     </div>
-    
+
     <div class="nav">
         <button class="active" onclick="showTab('dashboard')">Dashboard</button>
         <button onclick="showTab('leads')">Leads</button>
@@ -218,8 +597,9 @@
         <button onclick="showTab('outreach')">WhatsApp</button>
         <button onclick="showTab('customers')">Clientes</button>
         <button onclick="showTab('nuevo')">+ Nuevo</button>
+        <button onclick="showTab('leadgen')" id="nav-leadgen">🔍 Lead Gen</button>
     </div>
-    
+
     <div class="main">
         <!-- Dashboard Tab -->
         <div id="dashboard" class="tab-content">
@@ -249,7 +629,7 @@
                     <div class="value" id="stat-enriquecidos">0</div>
                 </div>
             </div>
-            
+
             <div class="grid-2">
                 <div class="card">
                     <h2>Leads por Estado</h2>
@@ -260,13 +640,13 @@
                     <div id="leads-by-niche"></div>
                 </div>
             </div>
-            
+
             <div class="card">
                 <h2>Leads Recientes</h2>
                 <div id="recent-leads"></div>
             </div>
         </div>
-        
+
         <!-- Leads Tab -->
         <div id="leads" class="tab-content" style="display: none;">
             <div class="card">
@@ -287,7 +667,7 @@
                 <div id="leads-list"></div>
             </div>
         </div>
-        
+
         <!-- Pipeline Tab -->
         <div id="pipeline" class="tab-content" style="display: none;">
             <div class="card">
@@ -295,7 +675,7 @@
                 <div class="pipeline-stages" id="pipeline-view"></div>
             </div>
         </div>
-        
+
         <!-- Outreach Tab -->
         <div id="outreach" class="tab-content" style="display: none;">
             <div class="card">
@@ -311,16 +691,18 @@
                 <div id="whatsapp-list"></div>
             </div>
         </div>
-        
+
         <!-- Customers Tab -->
         <div id="customers" class="tab-content" style="display: none;">
             <div class="card">
                 <h2>Clientes</h2>
-                <input type="text" class="search-box" placeholder="Buscar clientes..." onkeyup="filterCustomers(this.value)" style="width: 100%; padding: 0.75rem; border: 1px solid #e0e0e0; border-radius: 4px; margin-bottom: 1rem;">
+                <input type="text" class="search-box" placeholder="Buscar clientes..."
+                    onkeyup="filterCustomers(this.value)"
+                    style="width: 100%; padding: 0.75rem; border: 1px solid #e0e0e0; border-radius: 4px; margin-bottom: 1rem;">
                 <div id="customers-list"></div>
             </div>
         </div>
-        
+
         <!-- Nuevo Tab -->
         <div id="nuevo" class="tab-content" style="display: none;">
             <div class="card">
@@ -390,18 +772,18 @@
     <script>
         const SUPABASE_URL = 'https://nvssvykqxaurtlgwxwwy.supabase.co';
         const SUPABASE_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im52c3N2eWtxeGF1cnRsZ3d4d3d5Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzI4OTIxNjUsImV4cCI6MjA4ODQ2ODE2NX0.onzmNQGBy6jDxWO7TcjZuyvgvId9HiGNzUNs1HmOAMk';
-        
+
         let customers = [];
         let leads = [];
         let opportunities = [];
-        
+
         async function apiGet(table) {
             const response = await fetch(`${SUPABASE_URL}/rest/v1/${table}?select=*`, {
                 headers: { 'apikey': SUPABASE_KEY, 'Authorization': `Bearer ${SUPABASE_KEY}` }
             });
             return response.json();
         }
-        
+
         async function apiPost(table, data) {
             const response = await fetch(`${SUPABASE_URL}/rest/v1/${table}`, {
                 method: 'POST',
@@ -415,7 +797,7 @@
             });
             return response;
         }
-        
+
         async function apiPatch(table, id, data) {
             const response = await fetch(`${SUPABASE_URL}/rest/v1/${table}?id=eq.${id}`, {
                 method: 'PATCH',
@@ -429,13 +811,13 @@
             });
             return response;
         }
-        
+
         async function loadData() {
             try {
                 customers = await apiGet('customers');
                 leads = await apiGet('leads');
                 opportunities = await apiGet('opportunities');
-                
+
                 populateNichoFilter();
                 updateStats();
                 renderRecentLeads();
@@ -447,7 +829,7 @@
                 console.error('Error:', error);
             }
         }
-        
+
         function populateNichoFilter() {
             const niches = [...new Set(leads.map(l => l.nicho).filter(n => n))];
             const select = document.getElementById('lead-nicho-filter');
@@ -458,7 +840,7 @@
                 select.appendChild(opt);
             });
         }
-        
+
         function updateStats() {
             document.getElementById('stat-leads').textContent = leads.length;
             document.getElementById('stat-customers').textContent = customers.length;
@@ -466,15 +848,15 @@
             document.getElementById('stat-contactados').textContent = leads.filter(l => l.estado === 'contactado').length;
             document.getElementById('stat-con-telefono').textContent = leads.filter(l => l.telefono || l.telefono_formateado).length;
             document.getElementById('stat-enriquecidos').textContent = leads.filter(l => l.enriquecido).length;
-            
+
             renderLeadsByStatus();
             renderLeadsByNiche();
         }
-        
+
         function renderLeadsByStatus() {
             const counts = {};
             leads.forEach(l => { counts[l.estado || 'nuevo'] = (counts[l.estado || 'nuevo'] || 0) + 1; });
-            
+
             let html = '<table><thead><tr><th>Estado</th><th>Cantidad</th></tr></thead><tbody>';
             Object.entries(counts).forEach(([estado, count]) => {
                 const badge = getBadgeClass(estado);
@@ -483,11 +865,11 @@
             html += '</tbody></table>';
             document.getElementById('leads-by-status').innerHTML = html;
         }
-        
+
         function renderLeadsByNiche() {
             const counts = {};
-            leads.forEach(l => { if(l.nicho) { counts[l.nicho] = (counts[l.nicho] || 0) + 1; }});
-            
+            leads.forEach(l => { if (l.nicho) { counts[l.nicho] = (counts[l.nicho] || 0) + 1; } });
+
             let html = '<table><thead><tr><th>Nicho</th><th>Cantidad</th></tr></thead><tbody>';
             Object.entries(counts).slice(0, 10).forEach(([nicho, count]) => {
                 html += `<tr><td>${nicho}</td><td>${count}</td></tr>`;
@@ -495,32 +877,45 @@
             html += '</tbody></table>';
             document.getElementById('leads-by-niche').innerHTML = html;
         }
-        
+
         function getBadgeClass(estado) {
             const classes = { 'nuevo': 'badge-nuevo', 'contactado': 'badge-contactado', 'calificado': 'badge-calificado', 'cliente': 'badge-cliente', 'convertido': 'badge-ganado' };
             return classes[estado] || 'badge-lead';
         }
-        
+
+        function getQualityClass(score) {
+            if (score >= 8) return 'q-high';
+            if (score >= 5) return 'q-med';
+            return 'q-low';
+        }
+
         function renderRecentLeads() {
             const container = document.getElementById('recent-leads');
-            const recent = leads.slice(0, 5);
-            
+            // Sort by creation date descending
+            const recent = [...leads].sort((a, b) => new Date(b.created_at) - new Date(a.created_at)).slice(0, 8);
+
             if (!recent.length) {
                 container.innerHTML = '<p class="loading">No hay leads</p>';
                 return;
             }
-            
-            let html = '<table><thead><tr><th>Nombre</th><th>Nicho</th><th>Ciudad</th><th>Estado</th><th>Acciones</th></tr></thead><tbody>';
+
+            let html = '<table><thead><tr><th>Score</th><th>Nombre</th><th>Nicho</th><th>Ciudad</th><th>Estado</th><th>Acciones</th></tr></thead><tbody>';
             recent.forEach(lead => {
                 const badge = getBadgeClass(lead.estado);
+                const qScore = lead.quality_score || 0;
+                const qClass = getQualityClass(qScore);
                 html += `
                     <tr>
-                        <td>${lead.nombre || 'Sin nombre'}</td>
+                        <td width="50"><div class="quality-ring ${qClass}">${qScore}</div></td>
+                        <td><div style="font-weight:700">${lead.nombre || 'Sin nombre'}</div><div style="font-size: 0.75rem; color: var(--text-dim)">${lead.origen || 'lead_gen'}</div></td>
                         <td>${lead.nicho || '-'}</td>
                         <td>${lead.ciudad || '-'}</td>
                         <td><span class="badge ${badge}">${lead.estado || 'nuevo'}</span></td>
                         <td>
-                            ${lead.telefono || lead.telefono_formateado ? `<a href="${generateWhatsAppLink(lead)}" target="_blank" class="btn btn-whatsapp">WhatsApp</a>` : ''}
+                            <div class="action-buttons">
+                                ${lead.telefono || lead.telefono_formateado ? `<a href="${generateWhatsAppLink(lead)}" target="_blank" class="btn btn-whatsapp">WA</a>` : ''}
+                                <button class="btn btn-primary" onclick="showLeadDetails('${lead.id}')">Ver</button>
+                            </div>
                         </td>
                     </tr>
                 `;
@@ -528,27 +923,27 @@
             html += '</tbody></table>';
             container.innerHTML = html;
         }
-        
+
         function generateWhatsAppLink(lead) {
             const phone = lead.telefono_formateado || lead.telefono || '';
             const cleanPhone = phone.replace(/\D/g, '');
             const message = encodeURIComponent(`Hola ${lead.nombre || ''}, te contactamos de DonNadie Apps. ¿Cómo podemos ayudarte?`);
             return `https://wa.me/${cleanPhone}?text=${message}`;
         }
-        
+
         function renderCustomers(filter = '') {
             const container = document.getElementById('customers-list');
-            const filtered = customers.filter(c => 
+            const filtered = customers.filter(c =>
                 c.nombre?.toLowerCase().includes(filter.toLowerCase()) ||
                 c.cedula?.includes(filter) ||
                 c.correo?.toLowerCase().includes(filter.toLowerCase())
             );
-            
+
             if (!filtered.length) {
                 container.innerHTML = '<p class="loading">No hay clientes</p>';
                 return;
             }
-            
+
             let html = '<table><thead><tr><th>Nombre</th><th>Cédula</th><th>Teléfono</th><th>WhatsApp</th><th>Correo</th><th>Estado</th></tr></thead><tbody>';
             filtered.forEach(c => {
                 html += `
@@ -565,18 +960,18 @@
             html += '</tbody></table>';
             container.innerHTML = html;
         }
-        
+
         function filterCustomers(value) {
             renderCustomers(value);
         }
-        
+
         function renderLeads() {
             const search = document.getElementById('lead-search').value.toLowerCase();
             const estado = document.getElementById('lead-estado-filter').value;
             const nicho = document.getElementById('lead-nicho-filter').value;
-            
+
             const filtered = leads.filter(l => {
-                const matchSearch = !search || 
+                const matchSearch = !search ||
                     l.nombre?.toLowerCase().includes(search) ||
                     l.nicho?.toLowerCase().includes(search) ||
                     l.ciudad?.toLowerCase().includes(search);
@@ -584,28 +979,32 @@
                 const matchNicho = !nicho || l.nicho === nicho;
                 return matchSearch && matchEstado && matchNicho;
             });
-            
+
             const container = document.getElementById('leads-list');
-            
+
             if (!filtered.length) {
                 container.innerHTML = '<p class="loading">No hay leads</p>';
                 return;
             }
-            
-            let html = '<table><thead><tr><th>Nombre</th><th>Nicho</th><th>Ciudad</th><th>Teléfono</th><th>Estado</th><th>Acciones</th></tr></thead><tbody>';
+
+            let html = '<table><thead><tr><th>Score</th><th>Nombre</th><th>Nicho</th><th>Ciudad</th><th>Acciones</th></tr></thead><tbody>';
             filtered.forEach(l => {
                 const badge = getBadgeClass(l.estado);
+                const qScore = l.quality_score || 0;
+                const qClass = getQualityClass(qScore);
                 const hasPhone = l.telefono || l.telefono_formateado;
                 html += `
                     <tr>
-                        <td>${l.nombre || 'Sin nombre'}</td>
+                        <td><div class="quality-ring ${qClass}">${qScore}</div></td>
+                        <td>
+                            <div style="font-weight:700">${l.nombre || 'Sin nombre'}</div>
+                            <span class="badge ${badge}">${l.estado || 'nuevo'}</span>
+                        </td>
                         <td>${l.nicho || '-'}</td>
                         <td>${l.ciudad || '-'}</td>
-                        <td>${hasPhone ? 'Sí' : 'No'}</td>
-                        <td><span class="badge ${badge}">${l.estado || 'nuevo'}</span></td>
                         <td class="action-buttons">
-                            ${hasPhone ? `<a href="${generateWhatsAppLink(l)}" target="_blank" class="btn btn-whatsapp">WhatsApp</a>` : ''}
-                            <button class="btn btn-primary" onclick="updateLeadStatus('${l.id}', 'contactado')">Contactar</button>
+                            ${hasPhone ? `<a href="${generateWhatsAppLink(l)}" target="_blank" class="btn btn-whatsapp">WA</a>` : ''}
+                            <button class="btn btn-primary" onclick="showLeadDetails('${l.id}')">Ver</button>
                         </td>
                     </tr>
                 `;
@@ -613,11 +1012,17 @@
             html += '</tbody></table>';
             container.innerHTML = html;
         }
-        
+
         function filterLeads() {
             renderLeads();
         }
-        
+
+        function showLeadDetails(id) {
+            const lead = leads.find(l => l.id === id);
+            if (!lead) return;
+            alert(`Detalles de ${lead.nombre}:\n\nNicho: ${lead.nicho}\nCiudad: ${lead.ciudad}\nEstado: ${lead.estado}\nScore: ${lead.quality_score || 0}\n\nNotas: ${lead.observaciones || 'Sin notas'}`);
+        }
+
         async function updateLeadStatus(id, estado) {
             try {
                 await apiPatch('leads', id, { estado: estado, actualizado_en: new Date().toISOString() });
@@ -626,11 +1031,11 @@
                 alert('Error actualizando: ' + error.message);
             }
         }
-        
+
         function renderPipeline() {
             const stages = ['nuevo', 'contactado', 'calificado', 'convertido', 'perdido'];
             const stageNames = { 'nuevo': 'Nuevo', 'contactado': 'Contactado', 'calificado': 'Calificado', 'convertido': 'Ganado', 'perdido': 'Perdido' };
-            
+
             let html = '';
             stages.forEach(stage => {
                 const stageLeads = leads.filter(l => l.estado === stage);
@@ -648,60 +1053,67 @@
             });
             document.getElementById('pipeline-view').innerHTML = html;
         }
-        
+
         function renderWhatsApp() {
             const search = document.getElementById('wa-search').value.toLowerCase();
             const filter = document.getElementById('wa-filter').value;
-            
+
             const filtered = leads.filter(l => {
                 const phone = l.telefono || l.telefono_formateado;
                 if (!phone) return false;
-                
-                const matchSearch = !search || 
+
+                const matchSearch = !search ||
                     l.nombre?.toLowerCase().includes(search) ||
                     l.nicho?.toLowerCase().includes(search);
-                const matchFilter = filter === 'todos' || 
+                const matchFilter = filter === 'todos' ||
                     (filter === 'sin-contactar' && l.estado === 'nuevo') ||
                     (filter === 'contactados' && l.whatsapp_enviado);
                 return matchSearch && matchFilter;
             });
-            
+
             const container = document.getElementById('whatsapp-list');
-            
+
             if (!filtered.length) {
                 container.innerHTML = '<p class="loading">No hay leads con teléfono</p>';
                 return;
             }
-            
+
             let html = '';
             filtered.forEach(l => {
                 const phone = l.telefono_formateado || l.telefono;
+                const qScore = l.quality_score || 0;
+                const qClass = getQualityClass(qScore);
                 html += `
-                    <div class="whatsapp-card">
-                        <div class="name">${l.nombre || 'Sin nombre'}</div>
-                        <div class="phone">${phone}</div>
-                        <div style="margin-top: 0.5rem;">
-                            <span class="badge ${getBadgeClass(l.estado)}">${l.estado || 'nuevo'}</span>
-                            <span style="color: #666; margin-left: 1rem;">${l.nicho || ''} ${l.ciudad ? '- ' + l.ciudad : ''}</span>
+                    <div class="whatsapp-card" style="display: flex; justify-content: space-between; align-items: center;">
+                        <div>
+                            <div style="display:flex; align-items:center; gap:10px;">
+                                <div class="quality-ring ${qClass}">${qScore}</div>
+                                <div class="name" style="font-weight:700; font-size:1.1rem">${l.nombre || 'Sin nombre'}</div>
+                            </div>
+                            <div class="phone" style="margin-top:5px; opacity:0.8">${phone}</div>
+                            <div style="margin-top: 0.5rem;">
+                                <span class="badge ${getBadgeClass(l.estado)}">${l.estado || 'nuevo'}</span>
+                                <span style="color: var(--text-dim); margin-left: 1rem; font-size:0.8rem">${l.nicho || ''} ${l.ciudad ? '- ' + l.ciudad : ''}</span>
+                            </div>
                         </div>
-                        <div style="margin-top: 1rem;">
-                            <a href="${generateWhatsAppLink(l)}" target="_blank" class="btn btn-whatsapp">Abrir WhatsApp</a>
-                            <button class="btn btn-primary" onclick="markWhatsAppSent('${l.id}')" style="margin-left: 0.5rem;">Marcar como enviado</button>
+                        <div class="action-buttons">
+                            <a href="${generateWhatsAppLink(l)}" target="_blank" class="btn btn-whatsapp">Abrir Chat</a>
+                            <button class="btn btn-primary" onclick="markWhatsAppSent('${l.id}')">Marcar Enviado</button>
                         </div>
                     </div>
                 `;
             });
             container.innerHTML = html;
         }
-        
+
         function filterWhatsApp() {
             renderWhatsApp();
         }
-        
+
         async function markWhatsAppSent(id) {
             try {
-                await apiPatch('leads', id, { 
-                    whatsapp_enviado: true, 
+                await apiPatch('leads', id, {
+                    whatsapp_enviado: true,
                     whatsapp_enviado_en: new Date().toISOString(),
                     estado: 'contactado'
                 });
@@ -711,20 +1123,25 @@
                 alert('Error: ' + error.message);
             }
         }
-        
+
         function showTab(tabId) {
             document.querySelectorAll('.tab-content').forEach(t => t.style.display = 'none');
             document.querySelectorAll('.nav button').forEach(b => b.classList.remove('active'));
             document.getElementById(tabId).style.display = 'block';
             event.target.classList.add('active');
+            // Lead Gen tab side-effects
+            if (tabId === 'leadgen') {
+                if (typeof checkServer === 'function') checkServer();
+                if (typeof updatePlatforms === 'function') updatePlatforms();
+            }
         }
-        
+
         async function saveNew(e) {
             e.preventDefault();
-            
+
             const tipo = document.getElementById('nuevo-tipo').value;
             const isLead = tipo === 'lead';
-            
+
             const data = {
                 nombre: document.getElementById('nuevo-nombre').value,
                 correo: document.getElementById('nuevo-correo').value || null,
@@ -739,9 +1156,9 @@
                 created_at: new Date().toISOString(),
                 updated_at: new Date().toISOString()
             };
-            
+
             const table = isLead ? 'leads' : 'customers';
-            
+
             try {
                 await apiPost(table, data);
                 alert('Guardado correctamente');
@@ -752,8 +1169,320 @@
                 alert('Error: ' + error.message);
             }
         }
-        
+
+        loadData();
+
+        /* ════════════════════════════════════════════════════
+           LEAD GEN PRO INTEGRATION
+           API bridge: http://localhost:5000
+        ════════════════════════════════════════════════════ */
+
+        // 100% CLOUD: La API se sirve desde la misma raíz que el CRM
+        const API_BASE = '';
+        let sseSource = null;
+        let scrapeRunning = false;
+
+        // Insert Lead Gen tab HTML
+        (function () {
+            const leadgenHtml = `
+<div id="leadgen" class="tab-content" style="display:none">
+    <div id="server-banner" class="server-banner offline">
+        <span id="server-icon">⚠️</span>
+        <span id="server-msg">Verificando conexión con API Server (localhost:5000)...</span>
+        <button class="btn-sync" onclick="checkServer()" style="margin-left:auto">Reconectar</button>
+    </div>
+
+    <div class="lg-stat-row">
+        <div class="lg-stat">
+            <div class="val" id="lg-total">—</div>
+            <div class="lbl">Total Local</div>
+        </div>
+        <div class="lg-stat">
+            <div class="val" id="lg-30d">—</div>
+            <div class="lbl">Últimos 30d</div>
+        </div>
+        <div class="lg-stat">
+            <div class="val" id="lg-pending-wa">—</div>
+            <div class="lbl">Pendiente WA</div>
+        </div>
+    </div>
+
+    <div class="leadgen-grid">
+        <!-- Panel Izquierdo: Configuración de Scraping -->
+        <div>
+            <div class="leadgen-form-card">
+                <h3>🎯 Configurar Búsqueda</h3>
+
+                <div class="form-row">
+                    <label>Nicho / Industria</label>
+                    <input type="text" id="lg-niche" value="Real Estate" placeholder="Real Estate, Insurance, Healthcare...">
+                </div>
+
+                <div class="form-row">
+                    <label>Tipo de Lead</label>
+                    <select id="lg-type" onchange="updatePlatforms()">
+                        <option value="both">Ambos (B2B + B2C)</option>
+                        <option value="b2b">B2B — Empresas</option>
+                        <option value="b2c">B2C — Consumidores</option>
+                    </select>
+                </div>
+
+                <div class="form-row">
+                    <label>País</label>
+                    <select id="lg-country" onchange="updatePlatforms()">
+                        <option value="USA">🇺🇸 USA</option>
+                        <option value="Venezuela">🇻🇪 Venezuela</option>
+                        <option value="Mexico">🇲🇽 México</option>
+                        <option value="Colombia">🇨🇴 Colombia</option>
+                        <option value="Argentina">🇦🇷 Argentina</option>
+                        <option value="Spain">🇪🇸 España</option>
+                    </select>
+                </div>
+
+                <div class="form-row">
+                    <label>Estado / Provincia</label>
+                    <input type="text" id="lg-state" placeholder="FL, California, Miranda...">
+                </div>
+
+                <div class="form-row">
+                    <label>Ciudad</label>
+                    <input type="text" id="lg-city" placeholder="Miami, Caracas, Bogotá...">
+                </div>
+
+                <div class="form-row">
+                    <label>Límite por plataforma</label>
+                    <input type="number" id="lg-limit" value="15" min="5" max="50">
+                </div>
+
+                <div class="form-row" id="b2b-platforms">
+                    <label>Plataformas B2B</label>
+                    <div class="platform-grid">
+                        <label class="platform-check"><input type="checkbox" id="p-linkedin" checked> LinkedIn</label>
+                        <label class="platform-check"><input type="checkbox" id="p-gmaps" checked> Google Maps</label>
+                        <label class="platform-check"><input type="checkbox" id="p-youtube-b2b"> YouTube</label>
+                    </div>
+                </div>
+
+                <div class="form-row" id="b2c-platforms">
+                    <label>Plataformas B2C</label>
+                    <div class="platform-grid">
+                        <label class="platform-check"><input type="checkbox" id="p-twitter" checked> Twitter/X</label>
+                        <label class="platform-check"><input type="checkbox" id="p-reddit" checked> Reddit</label>
+                        <label class="platform-check"><input type="checkbox" id="p-youtube-b2c" checked> YouTube</label>
+                        <label class="platform-check"><input type="checkbox" id="p-facebook"> Facebook</label>
+                    </div>
+                </div>
+
+                <button class="btn-run" id="btn-run-scrape" onclick="startScraping()">
+                    ⚡ Ejecutar Scraping
+                </button>
+
+                <button class="btn-sync" style="width:100%;margin-top:0.75rem" onclick="syncToCloud()">
+                    ☁️ Sincronizar a Cloud (Supabase)
+                </button>
+            </div>
+        </div>
+
+        <!-- Panel Derecho: Terminal + Info -->
+        <div>
+            <div class="leadgen-form-card" style="margin-bottom:1.5rem">
+                <h3>🖥 Terminal de Logs</h3>
+                <div class="log-terminal" id="log-terminal">[Esperando comando...]
+</div>
+                <div style="display:flex;gap:0.5rem;margin-top:0.75rem">
+                    <button class="btn-sync" onclick="clearLogs()">Limpiar</button>
+                    <button class="btn-sync" onclick="loadLocalStats()">Actualizar Stats</button>
+                    <span id="scrape-status" style="margin-left:auto;font-size:0.8rem;color:var(--text-dim)">Inactivo</span>
+                </div>
+            </div>
+
+            <div class="leadgen-form-card">
+                <h3>📊 Top Nichos (Local)</h3>
+                <div id="lg-nicho-breakdown" style="color:var(--text-dim);font-size:0.85rem">Cargando...</div>
+            </div>
+        </div>
+    </div>
+</div>`;
+            document.querySelector('.main').insertAdjacentHTML('beforeend', leadgenHtml);
+        })();
+
+        /** Check if the local API server is reachable */
+        async function checkServer() {
+            const banner = document.getElementById('server-banner');
+            const msg = document.getElementById('server-msg');
+            const icon = document.getElementById('server-icon');
+            try {
+                const res = await fetch(`${API_BASE}/api/health`, { signal: AbortSignal.timeout(3000) });
+                if (res.ok) {
+                    banner.className = 'server-banner online';
+                    icon.textContent = '🟢';
+                    msg.textContent = 'API Server en línea — http://localhost:5000';
+                    loadLocalStats();
+                    return true;
+                }
+            } catch { }
+            banner.className = 'server-banner offline';
+            icon.textContent = '⚠️';
+            msg.innerHTML = 'API Server offline. Ejecuta <code>start_api_server.bat</code> en lead_gen_pro/';
+            return false;
+        }
+
+        /** Load local DB statistics from Flask */
+        async function loadLocalStats() {
+            try {
+                const res = await fetch(`${API_BASE}/api/stats`);
+                const d = await res.json();
+                document.getElementById('lg-total').textContent = d.total ?? '—';
+                document.getElementById('lg-30d').textContent = d.leads_30d ?? '—';
+                document.getElementById('lg-pending-wa').textContent = d.pending_whatsapp ?? '—';
+
+                // Nicho breakdown
+                const elem = document.getElementById('lg-nicho-breakdown');
+                if (d.by_niche && Object.keys(d.by_niche).length) {
+                    let html = '<table style="width:100%;border-collapse:collapse">';
+                    for (const [n, cnt] of Object.entries(d.by_niche)) {
+                        html += `<tr><td style="padding:0.35rem 0;color:var(--text-main)">${n}</td>
+                                 <td style="text-align:right;color:#818cf8;font-weight:700">${cnt}</td></tr>`;
+                    }
+                    html += '</table>';
+                    elem.innerHTML = html;
+                } else {
+                    elem.textContent = 'No hay datos aún.';
+                }
+            } catch (e) {
+                document.getElementById('lg-total').textContent = '—';
+            }
+        }
+
+        /** Show/hide platform groups based on lead type */
+        function updatePlatforms() {
+            const type = document.getElementById('lg-type').value;
+            document.getElementById('b2b-platforms').style.display = (type === 'b2c') ? 'none' : 'block';
+            document.getElementById('b2c-platforms').style.display = (type === 'b2b') ? 'none' : 'block';
+        }
+
+        /** Append a line to the terminal */
+        function appendLog(line) {
+            const t = document.getElementById('log-terminal');
+            const span = document.createElement('span');
+            const cls = line.includes('[ERR]') || line.includes('Error') ? 'log-err'
+                : line.includes('[DONE]') || line.includes('[SYNC]') ? 'log-done' : '';
+            if (cls) span.className = cls;
+            span.textContent = line + '\n';
+            t.appendChild(span);
+            t.scrollTop = t.scrollHeight;
+        }
+
+        function clearLogs() {
+            document.getElementById('log-terminal').textContent = '[Logs limpios]\n';
+        }
+
+        /** Launch the scraping pipeline */
+        async function startScraping() {
+            if (scrapeRunning) return;
+            const online = await checkServer();
+            if (!online) return;
+
+            const type = document.getElementById('lg-type').value;
+
+            const b2b = [];
+            if (type !== 'b2c') {
+                if (document.getElementById('p-linkedin').checked) b2b.push('linkedin');
+                if (document.getElementById('p-gmaps').checked) b2b.push('google_maps');
+                if (document.getElementById('p-youtube-b2b').checked) b2b.push('youtube');
+            }
+            const b2c = [];
+            if (type !== 'b2b') {
+                if (document.getElementById('p-twitter').checked) b2c.push('twitter');
+                if (document.getElementById('p-reddit').checked) b2c.push('reddit');
+                if (document.getElementById('p-youtube-b2c').checked) b2c.push('youtube');
+                if (document.getElementById('p-facebook').checked) b2c.push('facebook');
+            }
+
+            const payload = {
+                niche: document.getElementById('lg-niche').value || 'Real Estate',
+                lead_type: type,
+                country: document.getElementById('lg-country').value,
+                state: document.getElementById('lg-state').value,
+                city: document.getElementById('lg-city').value,
+                limit: parseInt(document.getElementById('lg-limit').value) || 15,
+                b2b_platforms: b2b,
+                b2c_platforms: b2c
+            };
+
+            clearLogs();
+            appendLog(`[INICIO] ${new Date().toLocaleTimeString()} — Lanzando pipeline...`);
+            appendLog(`Nicho: ${payload.niche} | Tipo: ${payload.lead_type} | Ciudad: ${payload.city || '—'}`);
+
+            scrapeRunning = true;
+            document.getElementById('btn-run-scrape').disabled = true;
+            document.getElementById('scrape-status').textContent = '⏳ Ejecutando...';
+
+            // POST to start the scrape
+            try {
+                const res = await fetch(`${API_BASE}/api/scrape`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(payload)
+                });
+                const d = await res.json();
+                if (!res.ok) {
+                    appendLog('[ERR] ' + (d.error || 'Error desconocido'));
+                    resetScrapeUI();
+                    return;
+                }
+            } catch (e) {
+                appendLog('[ERR] No se pudo conectar: ' + e.message);
+                resetScrapeUI();
+                return;
+            }
+
+            // Subscribe to SSE log stream
+            if (sseSource) sseSource.close();
+            sseSource = new EventSource(`${API_BASE}/api/stream`);
+            sseSource.onmessage = (e) => {
+                if (e.data === '[END]') {
+                    sseSource.close();
+                    resetScrapeUI();
+                    loadLocalStats();
+                    // Refresh cloud leads
+                    loadData();
+                    return;
+                }
+                if (e.data !== '[PING]') appendLog(e.data);
+            };
+            sseSource.onerror = () => {
+                sseSource.close();
+                resetScrapeUI();
+            };
+        }
+
+        function resetScrapeUI() {
+            scrapeRunning = false;
+            document.getElementById('btn-run-scrape').disabled = false;
+            document.getElementById('scrape-status').textContent = '✅ Completado';
+            setTimeout(() => {
+                document.getElementById('scrape-status').textContent = 'Inactivo';
+            }, 5000);
+        }
+
+        /** Force sync local SQLite → Supabase */
+        async function syncToCloud() {
+            const online = await checkServer();
+            if (!online) return;
+            appendLog('[SYNC] Iniciando sincronización con Supabase...');
+            try {
+                const res = await fetch(`${API_BASE}/api/sync`, { method: 'POST' });
+                const d = await res.json();
+                appendLog(`[SYNC] ${d.message} — Sincronizados: ${d.result || ''}`);
+                loadData();
+            } catch (e) {
+                appendLog('[ERR] Error sincronizando: ' + e.message);
+            }
+        }
+
         loadData();
     </script>
 </body>
-</html>
+
+</html>