feat: estructura base del sistema multiagente monitor-ml-aceitess

- Framework de agentes: runAgent() con loop tool-calling, subAgentTool() para delegación jerárquica
- Orquestador con clasificación de intents en dos niveles (keywords + LLM Haiku fallback)
- Agentes especialistas: price_monitor (precios palma) y demand_monitor (ventas/demanda)
- Agent Lab: meta-agente de auto-mejora con autonomía reactiva/proactiva
- Integración Telegram via webhook (python-telegram-bot)
- Cliente Supabase + schema SQL completo (agentes, ML, ventas, research, audit log)
- app.py: HuggingFace Space con Gradio dashboard + FastAPI webhook endpoint
- Cron GitHub Actions diario (03:00 UTC): scraping, scoring, Agent Lab, reporte Telegram
- Diseñado para recibir datos reales en Excel (aceites, mantecas) en Fase 2

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.env.example

@@ -0,0 +1,14 @@
+# === Anthropic ===
+ANTHROPIC_API_KEY=sk-ant-...
+
+# === Telegram ===
+TELEGRAM_BOT_TOKEN=         # Obtenido de @BotFather
+TELEGRAM_WEBHOOK_URL=       # URL pública del HuggingFace Space, ej: https://user-monitor-ml-aceitess.hf.space
+
+# === Supabase ===
+SUPABASE_URL=https://xxxx.supabase.co
+SUPABASE_KEY=eyJ...         # anon/service_role key
+
+# === App ===
+APP_ENV=development         # development | production
+LOG_LEVEL=INFO

.github/workflows/daily_research.yml

@@ -0,0 +1,32 @@
+name: Daily Research Pipeline
+
+on:
+  schedule:
+    - cron: "0 3 * * *"   # 03:00 UTC = 22:00 Ecuador (UTC-5)
+  workflow_dispatch:        # Permite ejecutar manualmente desde GitHub Actions
+
+jobs:
+  research:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: "pip"
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run research pipeline
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          SUPABASE_URL: ${{ secrets.SUPABASE_URL }}
+          SUPABASE_KEY: ${{ secrets.SUPABASE_KEY }}
+          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          TELEGRAM_ADMIN_CHAT_ID: ${{ secrets.TELEGRAM_ADMIN_CHAT_ID }}
+        run: python -m cron.research_pipeline

.gitignore

@@ -0,0 +1,37 @@
+# Variables de entorno — NUNCA subir a git
+.env
+*.env
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+.Python
+*.egg-info/
+dist/
+build/
+.eggs/
+.pytest_cache/
+
+# Entornos virtuales
+venv/
+.venv/
+env/
+
+# Datos crudos y modelos (pueden ser grandes)
+data/raw/*
+data/processed/*
+models/*.pkl
+models/*.joblib
+models/*.h5
+!data/raw/.gitkeep
+!data/processed/.gitkeep
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db

CLAUDE.md

@@ -0,0 +1,81 @@
+# monitor-ml-aceitess
+
+Sistema multiagente de monitoreo ML para producción y venta de aceites comestibles.
+Desplegado en HuggingFace Spaces. Interfaz vía Telegram bot.
+
+## Stack
+
+- **Runtime**: Python 3.11+
+- **Framework agentes**: Anthropic SDK (claude-haiku-4-5 para clasificación, claude-sonnet-4-6 para agentes)
+- **Interfaz**: Telegram bot (webhook) + Gradio dashboard
+- **Base de datos**: Supabase (PostgreSQL)
+- **Despliegue**: HuggingFace Spaces (Gradio + FastAPI)
+- **Cron**: GitHub Actions
+
+## Estructura
+
+```
+agents/
+  base_agent.py        # runAgent() — loop de tool-calling
+  orchestrator.py      # Clasificación de intents + routing
+  agent_lab.py         # Meta-agente de auto-mejora
+  specialists/
+    price_monitor.py   # Monitoreo modelo forecasting de precios (aceite de palma)
+    demand_monitor.py  # Monitoreo modelo forecasting de demanda/ventas
+tools/
+  sub_agent_tool.py    # subAgentTool() — delegación jerárquica
+telegram/
+  bot.py               # Webhook handler + comandos
+database/
+  supabase_client.py   # Cliente Supabase
+  schema.sql           # Schema completo
+data/
+  raw/                 # Datasets crudos (FRED, World Bank, Kaggle)
+  processed/           # Datasets procesados
+models/                # Modelos ML entrenados (.pkl, etc.)
+cron/
+  research_pipeline.py # Pipeline diario de investigación (GitHub Actions)
+app.py                 # Entry point HuggingFace Space
+```
+
+## Fuentes de datos
+
+- **Precio mundial aceite de palma**: FRED (PPOILUSDM), World Bank Pink Sheet
+- **Ecuador producción/precios**: CFN Ficha Sectorial, ANCUPA, USDA FAS PSD Online
+- **Ventas FMCG**: Kaggle FMCG Daily Sales 2022–2024
+- **Futuro**: base de datos plana Excel del negocio real (aceites, mantecas, otros productos)
+
+## Agentes especialistas
+
+| Agente | Modelo | Función |
+|--------|--------|---------|
+| price_monitor | sonnet-4-6 | Monitorea modelo de forecasting de precios de palma |
+| demand_monitor | sonnet-4-6 | Monitorea modelo de forecasting de demanda/ventas |
+| agent_lab | sonnet-4-6 | Meta-agente: lee configs, aplica mejoras reactivas, encola proactivas |
+| orchestrator | haiku-4-5 | Clasifica intents y enruta al especialista correcto |
+
+## Autonomía de Agent Lab
+
+- **REACTIVA** (auto-aplica): corrección de errores, anti-patrones en prompts, memorias de feedback
+- **PROACTIVA** (requiere aprobación vía Telegram): nuevas herramientas, restructuración, cambio de modelo
+
+## Comandos de desarrollo
+
+```bash
+# Instalar dependencias
+pip install -r requirements.txt
+
+# Copiar y configurar variables de entorno
+cp .env.example .env
+
+# Ejecutar localmente
+python app.py
+
+# Aplicar schema a Supabase
+# Ejecutar database/schema.sql en el SQL Editor de Supabase
+```
+
+## Control de versiones
+
+Después de cada cambio relevante: commit + push a GitHub inmediatamente.
+Formato: `<tipo>: <descripción en imperativo>`

agents/__init__.py

@@ -0,0 +1,4 @@
+from agents.base_agent import run_agent
+from agents.orchestrator import Orchestrator
+
+__all__ = ["run_agent", "Orchestrator"]

agents/agent_lab.py

@@ -0,0 +1,305 @@
+"""
+agent_lab.py
+------------
+Meta-agente de auto-mejora. Cada noche (via GitHub Actions cron):
+  1. Lee los findings de research recientes
+  2. Revisa las configs de todos los agentes
+  3. Aplica mejoras REACTIVAS automáticamente
+  4. Encola mejoras PROACTIVAS para aprobación humana vía Telegram
+
+Autonomía:
+  REACTIVA (auto-aplica):
+    - Corrección de errores recurrentes en tool calls
+    - Anti-patrones en system prompts
+    - Memorias de feedback basadas en errores claros
+
+  PROACTIVA (requiere aprobación):
+    - Agregar nuevas herramientas a agentes
+    - Restructurar system prompts significativamente
+    - Cambiar modelo (haiku ↔ sonnet)
+    - Agregar nuevos sub-agentes
+"""
+
+import logging
+from agents.base_agent import run_agent, MODEL_SMART
+from database.supabase_client import get_supabase
+
+logger = logging.getLogger(__name__)
+
+SYSTEM_PROMPT = """Eres Agent Lab, el meta-agente de mejora continua del sistema monitor-ml-aceitess.
+
+Tu misión diaria:
+1. Consultar los findings de investigación recientes (relevancia > 0.5)
+2. Leer la configuración de cada agente del sistema
+3. Generar recomendaciones específicas y accionables
+4. Auto-aplicar las REACTIVAS, encolar las PROACTIVAS para aprobación humana
+
+## Autonomía
+
+### REACTIVA (aplica inmediatamente, sin pedir permiso):
+- Corrección de patrones de error en tool calls
+- Mejora de instrucciones poco claras en system prompts
+- Adición de memorias de feedback basadas en errores documentados
+
+### PROACTIVA (encola para aprobación humana):
+- Agregar nuevas herramientas a agentes existentes
+- Restructuración significativa de system prompts
+- Cambio de modelo tier (haiku → sonnet o viceversa)
+- Nuevos agentes especialistas
+- Adopción de técnicas de research con score > 0.8
+
+## Principios
+- Toda recomendación debe tener un finding de research como respaldo (trazabilidad)
+- Cada config de agente tiene un version_hash; no re-apliques si no cambió
+- Monitorea skill bloat: alerta si un agente tiene 5+ herramientas, recomienda split en 8+
+- Sé conservador: menos cambios con más impacto es mejor que muchos cambios pequeños
+
+Responde en español."""
+
+TOOLS = [
+    {
+        "name": "list_agents",
+        "description": "Lista todos los agentes registrados en el sistema con su nombre y descripción.",
+        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "get_agent_config",
+        "description": "Lee la configuración completa de un agente: system prompt, herramientas, skills, version hash.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "agent_name": {"type": "string", "description": "Nombre del agente."}
+            },
+            "required": ["agent_name"],
+        },
+    },
+    {
+        "name": "search_research",
+        "description": "Busca findings de investigación recientes filtrados por score mínimo de relevancia.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "min_score": {
+                    "type": "number",
+                    "description": "Score mínimo de relevancia (0.0 a 1.0).",
+                    "default": 0.5,
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Máximo de resultados.",
+                    "default": 20,
+                },
+            },
+        },
+    },
+    {
+        "name": "create_recommendation",
+        "description": "Crea una recomendación de mejora para un agente. Tipo 'reactive' se auto-aplica; 'proactive' espera aprobación humana.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "type": {"type": "string", "enum": ["reactive", "proactive"]},
+                "category": {"type": "string", "description": "Categoría: 'prompt', 'tool', 'model', 'skill', 'memory'"},
+                "target_agent": {"type": "string"},
+                "title": {"type": "string"},
+                "description": {"type": "string"},
+                "rationale": {"type": "string", "description": "Justificación basada en research o evidencia."},
+                "priority": {"type": "integer", "default": 5, "description": "1 (baja) a 10 (crítica)"},
+            },
+            "required": ["type", "category", "target_agent", "title", "description", "rationale"],
+        },
+    },
+    {
+        "name": "apply_reactive_fix",
+        "description": "Aplica inmediatamente una mejora reactiva a un agente (corrección de prompt, memoria de feedback, etc.).",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "recommendation_id": {"type": "string"},
+                "agent_name": {"type": "string"},
+                "change_type": {"type": "string", "enum": ["prompt_fix", "memory_update", "skill_update"]},
+                "before_state": {"type": "string"},
+                "after_state": {"type": "string"},
+            },
+            "required": ["recommendation_id", "agent_name", "change_type", "after_state"],
+        },
+    },
+    {
+        "name": "check_skill_bloat",
+        "description": "Verifica si algún agente tiene demasiadas herramientas (alerta en 5+, split recomendado en 8+).",
+        "input_schema": {"type": "object", "properties": {}},
+    },
+]
+
+
+def _list_agents() -> dict:
+    try:
+        db = get_supabase()
+        result = db.table("agents").select("name, description, updated_at").execute()
+        if result.data:
+            return {"agents": result.data}
+        # Fallback: agentes hardcoded si aún no hay DB
+        return {
+            "agents": [
+                {"name": "price_monitor", "description": "Monitoreo forecasting de precios"},
+                {"name": "demand_monitor", "description": "Monitoreo forecasting de demanda"},
+                {"name": "agent_lab", "description": "Meta-agente de mejora"},
+                {"name": "orchestrator", "description": "Clasificación de intents y routing"},
+            ]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _get_agent_config(agent_name: str) -> dict:
+    try:
+        db = get_supabase()
+        result = (
+            db.table("agents")
+            .select("*")
+            .eq("name", agent_name)
+            .execute()
+        )
+        if result.data:
+            return result.data[0]
+        return {"message": f"Agente '{agent_name}' no encontrado en la base de datos."}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _search_research(min_score: float = 0.5, limit: int = 20) -> dict:
+    try:
+        db = get_supabase()
+        result = (
+            db.table("agent_lab_research")
+            .select("title, summary, relevance_score, source_url, tags, created_at")
+            .gte("relevance_score", min_score)
+            .order("relevance_score", desc=True)
+            .limit(limit)
+            .execute()
+        )
+        if result.data:
+            return {"findings": result.data, "count": len(result.data)}
+        return {"message": "No hay findings de research aún. Ejecutar el cron de investigación primero."}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _create_recommendation(
+    type: str,
+    category: str,
+    target_agent: str,
+    title: str,
+    description: str,
+    rationale: str,
+    priority: int = 5,
+) -> dict:
+    try:
+        db = get_supabase()
+        result = db.table("agent_lab_recommendations").insert({
+            "type": type,
+            "category": category,
+            "target_agent": target_agent,
+            "title": title,
+            "description": description,
+            "rationale": rationale,
+            "priority": priority,
+            "status": "pending",
+        }).execute()
+        return {"success": True, "id": result.data[0]["id"] if result.data else None}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _apply_reactive_fix(
+    recommendation_id: str,
+    agent_name: str,
+    change_type: str,
+    after_state: str,
+    before_state: str = "",
+) -> dict:
+    try:
+        db = get_supabase()
+        # Registrar en audit log
+        db.table("agent_lab_changes").insert({
+            "recommendation_id": recommendation_id,
+            "change_type": "auto",
+            "target_agent": agent_name,
+            "description": f"Fix reactivo: {change_type}",
+            "before_state": {"content": before_state},
+            "after_state": {"content": after_state},
+        }).execute()
+
+        # Marcar recomendación como aplicada
+        db.table("agent_lab_recommendations").update(
+            {"status": "applied"}
+        ).eq("id", recommendation_id).execute()
+
+        return {"success": True, "applied": change_type, "agent": agent_name}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _check_skill_bloat() -> dict:
+    try:
+        db = get_supabase()
+        result = db.table("agents").select("name, tools").execute()
+        if not result.data:
+            return {"message": "No hay agentes registrados en DB aún."}
+
+        report = []
+        for agent in result.data:
+            tools = agent.get("tools") or []
+            count = len(tools) if isinstance(tools, list) else 0
+            status = "ok"
+            if count >= 8:
+                status = "split_recommended"
+            elif count >= 5:
+                status = "flag"
+            report.append({"agent": agent["name"], "tool_count": count, "status": status})
+
+        return {"bloat_report": report}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+TOOL_HANDLERS = {
+    "list_agents": _list_agents,
+    "get_agent_config": _get_agent_config,
+    "search_research": _search_research,
+    "create_recommendation": _create_recommendation,
+    "apply_reactive_fix": _apply_reactive_fix,
+    "check_skill_bloat": _check_skill_bloat,
+}
+
+
+class AgentLabAgent:
+    """Meta-agente de mejora continua del sistema."""
+
+    def run(self, message: str, session_history: list | None = None) -> tuple[str, list]:
+        return run_agent(
+            system_prompt=SYSTEM_PROMPT,
+            user_message=message,
+            tools=TOOLS,
+            tool_handlers=TOOL_HANDLERS,
+            model=MODEL_SMART,
+            conversation_history=session_history,
+        )
+
+    def run_daily_cycle(self) -> str:
+        """
+        Ejecuta el ciclo completo de mejora diaria.
+        Llamado por el cron de GitHub Actions.
+        """
+        logger.info("[AgentLab] iniciando ciclo diario de mejora")
+        response, _ = self.run(
+            "Ejecuta el ciclo diario completo: "
+            "1) Revisa findings de research con score > 0.5. "
+            "2) Lista todos los agentes y revisa sus configs. "
+            "3) Genera recomendaciones específicas. "
+            "4) Aplica las reactivas. "
+            "5) Verifica skill bloat. "
+            "6) Resume qué cambió y qué queda pendiente de aprobación."
+        )
+        logger.info("[AgentLab] ciclo diario completado")
+        return response

agents/base_agent.py

@@ -0,0 +1,108 @@
+"""
+base_agent.py
+-------------
+Core del framework de agentes. Implementa runAgent() con loop de tool-calling
+contra la API de Anthropic, memoria de conversación por sesión, y soporte para
+delegación jerárquica vía subAgentTool().
+"""
+
+import logging
+from typing import Callable, Any
+import anthropic
+
+logger = logging.getLogger(__name__)
+
+# Modelos disponibles
+MODEL_FAST = "claude-haiku-4-5-20251001"    # Clasificación, tareas simples
+MODEL_SMART = "claude-sonnet-4-6"           # Agentes especialistas, Agent Lab
+
+
+def run_agent(
+    system_prompt: str,
+    user_message: str,
+    tools: list[dict],
+    tool_handlers: dict[str, Callable[..., Any]],
+    model: str = MODEL_SMART,
+    conversation_history: list[dict] | None = None,
+    max_iterations: int = 15,
+) -> tuple[str, list[dict]]:
+    """
+    Ejecuta un agente con loop de tool-calling hasta obtener respuesta final.
+
+    Args:
+        system_prompt:        Instrucciones del agente.
+        user_message:         Mensaje del usuario para esta llamada.
+        tools:                Lista de definiciones de herramientas (formato Anthropic).
+        tool_handlers:        Dict {nombre_tool: función_handler}.
+        model:                Modelo a usar (default: sonnet-4-6).
+        conversation_history: Historial previo de la sesión (se modifica in-place).
+        max_iterations:       Límite de ciclos para evitar loops infinitos.
+
+    Returns:
+        (respuesta_final: str, historial_actualizado: list)
+    """
+    client = anthropic.Anthropic()
+
+    messages = conversation_history if conversation_history is not None else []
+    messages.append({"role": "user", "content": user_message})
+
+    for iteration in range(max_iterations):
+        logger.debug(f"[run_agent] iteración {iteration + 1}, modelo={model}")
+
+        response = client.messages.create(
+            model=model,
+            max_tokens=4096,
+            system=system_prompt,
+            tools=tools if tools else [],
+            messages=messages,
+        )
+
+        # Agregar respuesta del asistente al historial
+        messages.append({"role": "assistant", "content": response.content})
+
+        # Sin tool calls → respuesta final
+        if response.stop_reason == "end_turn":
+            final_text = _extract_text(response.content)
+            logger.debug(f"[run_agent] respuesta final obtenida en iteración {iteration + 1}")
+            return final_text, messages
+
+        # Procesar tool calls
+        if response.stop_reason == "tool_use":
+            tool_results = []
+
+            for block in response.content:
+                if block.type != "tool_use":
+                    continue
+
+                logger.debug(f"[run_agent] ejecutando tool: {block.name}")
+                handler = tool_handlers.get(block.name)
+
+                if handler:
+                    try:
+                        result = handler(**block.input)
+                    except Exception as e:
+                        result = f"Error ejecutando {block.name}: {str(e)}"
+                        logger.error(f"[run_agent] error en tool {block.name}: {e}")
+                else:
+                    result = f"Herramienta '{block.name}' no encontrada."
+                    logger.warning(f"[run_agent] tool no encontrada: {block.name}")
+
+                tool_results.append({
+                    "type": "tool_result",
+                    "tool_use_id": block.id,
+                    "content": str(result),
+                })
+
+            messages.append({"role": "user", "content": tool_results})
+
+    logger.warning(f"[run_agent] límite de iteraciones alcanzado ({max_iterations})")
+    return "Se alcanzó el límite de iteraciones sin obtener respuesta final.", messages
+
+
+def _extract_text(content_blocks: list) -> str:
+    """Extrae el texto de los bloques de contenido de la respuesta."""
+    parts = []
+    for block in content_blocks:
+        if hasattr(block, "text"):
+            parts.append(block.text)
+    return "\n".join(parts).strip()

agents/orchestrator.py

@@ -0,0 +1,160 @@
+"""
+orchestrator.py
+---------------
+Punto de entrada único del sistema. Clasifica el intent del mensaje entrante
+y lo enruta al agente especialista correcto.
+
+Clasificación en dos niveles (según el PDF):
+  1. Fast path: keyword matching (gratis, ~0ms). Cubre ~70% de los mensajes.
+  2. Slow path: LLM fallback con Haiku si el score de keywords es insuficiente.
+"""
+
+import logging
+import re
+from dataclasses import dataclass, field
+from agents.base_agent import run_agent, MODEL_FAST
+
+logger = logging.getLogger(__name__)
+
+SCORE_THRESHOLD = 0.6  # Score mínimo para rutear por keywords
+
+
+@dataclass
+class AgentRoute:
+    """Definición de un agente disponible para routing."""
+    name: str
+    description: str
+    keywords: list[str]
+    weight: float = 1.0
+
+
+# Registro de agentes y sus palabras clave
+AGENT_REGISTRY: list[AgentRoute] = [
+    AgentRoute(
+        name="price_monitor",
+        description="Monitorea el modelo de forecasting de precios del aceite de palma. Analiza tendencias, alertas de precio, drift del modelo y métricas de forecasting.",
+        keywords=[
+            "precio", "price", "palma", "palm", "cotizaci", "commodity",
+            "tendencia", "trend", "forecast", "pron\u00f3stico", "pronostico",
+            "fred", "world bank", "imf", "mercado", "mercados", "coste", "costo",
+            "barrel", "tonel", "usd", "d\u00f3lar", "dolar",
+        ],
+        weight=1.2,
+    ),
+    AgentRoute(
+        name="demand_monitor",
+        description="Monitorea el modelo de forecasting de demanda y ventas. Analiza volúmenes, inventario, canales, regiones y métricas del modelo.",
+        keywords=[
+            "demanda", "demand", "venta", "sales", "inventario", "inventory",
+            "stock", "pedido", "order", "canal", "channel", "regi\u00f3n", "region",
+            "producci\u00f3n", "produccion", "production", "distribuci\u00f3n", "distribucion",
+            "aceite", "manteca", "liter", "litro", "kilo", "kg", "unidad",
+            "fmcg", "sku", "producto", "product",
+        ],
+        weight=1.2,
+    ),
+    AgentRoute(
+        name="agent_lab",
+        description="Meta-agente que gestiona mejoras del sistema. Revisa recomendaciones pendientes, aplica fixes y reporta el estado del sistema.",
+        keywords=[
+            "mejora", "improve", "update", "actualizar", "recomendar", "recomendaci\u00f3n",
+            "recomendacion", "lab", "agente", "agent", "config", "configuraci\u00f3n",
+            "configuracion", "sistema", "system", "fix", "arreglar", "optimizar",
+            "pendiente", "pending", "aprobar", "approve", "rechazar", "reject",
+        ],
+        weight=1.0,
+    ),
+]
+
+ORCHESTRATOR_SYSTEM_PROMPT = """Eres el clasificador de intents del sistema monitor-ml-aceitess.
+Tu única tarea es determinar a qué agente debe ir el mensaje del usuario.
+
+Agentes disponibles:
+- price_monitor: preguntas sobre precios del aceite de palma, forecasting de precios, tendencias de mercado
+- demand_monitor: preguntas sobre ventas, demanda, inventario, producción, canales de distribución
+- agent_lab: gestión del sistema de agentes, recomendaciones, mejoras, estado del sistema
+
+Responde ÚNICAMENTE con el nombre exacto del agente (price_monitor, demand_monitor, o agent_lab).
+Sin explicación. Sin texto adicional."""
+
+
+class Orchestrator:
+    """
+    Enruta mensajes al agente especialista correcto.
+    Usa keyword matching primero; si el score es bajo, usa Haiku como fallback.
+    """
+
+    def __init__(self):
+        self._invocation_counts: dict[str, int] = {r.name: 0 for r in AGENT_REGISTRY}
+
+    def classify(self, message: str) -> str:
+        """
+        Clasifica el intent del mensaje y devuelve el nombre del agente destino.
+        """
+        # Fast path: keyword matching
+        agent_name, score = self._keyword_match(message)
+
+        if score >= SCORE_THRESHOLD:
+            logger.info(f"[Orchestrator] fast path → {agent_name} (score={score:.2f})")
+            self._invocation_counts[agent_name] += 1
+            return agent_name
+
+        # Slow path: LLM fallback
+        logger.info(f"[Orchestrator] score bajo ({score:.2f}), usando LLM fallback")
+        agent_name = self._llm_classify(message)
+        self._invocation_counts[agent_name] += 1
+        return agent_name
+
+    def _keyword_match(self, message: str) -> tuple[str, float]:
+        """
+        Calcula score por palabras clave para cada agente.
+        Devuelve (mejor_agente, score).
+        """
+        text = message.lower()
+        best_agent = AGENT_REGISTRY[0].name
+        best_score = 0.0
+
+        for route in AGENT_REGISTRY:
+            matches = sum(1 for kw in route.keywords if kw in text)
+            if route.keywords:
+                score = (matches / len(route.keywords)) * route.weight * 10
+                # Normalizar a [0, 1]
+                score = min(score, 1.0)
+            else:
+                score = 0.0
+
+            if score > best_score:
+                best_score = score
+                best_agent = route.name
+
+        return best_agent, best_score
+
+    def _llm_classify(self, message: str) -> str:
+        """
+        Usa claude-haiku para clasificar el intent cuando keywords no alcanzan el threshold.
+        """
+        try:
+            response, _ = run_agent(
+                system_prompt=ORCHESTRATOR_SYSTEM_PROMPT,
+                user_message=message,
+                tools=[],
+                tool_handlers={},
+                model=MODEL_FAST,
+                max_iterations=1,
+            )
+            agent_name = response.strip().lower()
+
+            valid_names = {r.name for r in AGENT_REGISTRY}
+            if agent_name in valid_names:
+                logger.info(f"[Orchestrator] LLM fallback → {agent_name}")
+                return agent_name
+
+            logger.warning(f"[Orchestrator] LLM devolvió nombre inválido: '{agent_name}', usando demand_monitor")
+        except Exception as e:
+            logger.error(f"[Orchestrator] error en LLM fallback: {e}")
+
+        return "demand_monitor"  # Default seguro
+
+    def get_stats(self) -> dict:
+        """Devuelve estadísticas de invocaciones por agente."""
+        return dict(self._invocation_counts)

agents/specialists/__init__.py

@@ -0,0 +1,4 @@
+from agents.specialists.price_monitor import PriceMonitorAgent
+from agents.specialists.demand_monitor import DemandMonitorAgent
+
+__all__ = ["PriceMonitorAgent", "DemandMonitorAgent"]

agents/specialists/demand_monitor.py

@@ -0,0 +1,244 @@
+"""
+demand_monitor.py
+-----------------
+Agente especialista: monitoreo del modelo de forecasting de demanda/ventas.
+
+Cubre:
+  - Volúmenes de venta (aceites, mantecas, otros productos)
+  - Inventario y stock
+  - Métricas del modelo de demanda
+  - Importación futura de datos Excel del negocio real
+
+Herramientas:
+  - get_demand_metrics         Métricas del modelo de demanda
+  - get_sales_summary          Resumen de ventas por período
+  - get_inventory_status       Estado de inventario actual
+  - import_excel_data          Importa datos planos desde Excel (futuro negocio real)
+"""
+
+import logging
+from agents.base_agent import run_agent, MODEL_SMART
+from database.supabase_client import get_supabase
+
+logger = logging.getLogger(__name__)
+
+SYSTEM_PROMPT = """Eres el agente monitor del modelo de forecasting de demanda y ventas.
+
+Tu rol:
+- Reportar el estado del modelo de predicción de demanda de productos
+- Analizar patrones de ventas por producto, canal y región
+- Alertar sobre desviaciones entre demanda prevista y real
+- Monitorear niveles de inventario y riesgo de desabasto
+- En el futuro, analizar datos reales de ventas del negocio (Excel)
+
+El negocio es una empresa ecuatoriana que produce y vende:
+  - Aceites comestibles (palma, girasol, soya, maíz)
+  - Mantecas
+  - Otros productos derivados
+
+Los datos actuales provienen del dataset FMCG Kaggle como proxy.
+En el futuro se usarán datos reales en formato Excel plano.
+
+Cuando reportes, incluye números específicos y comparaciones con períodos anteriores.
+Responde siempre en español."""
+
+TOOLS = [
+    {
+        "name": "get_demand_metrics",
+        "description": "Obtiene las métricas del modelo de forecasting de demanda (MAE, RMSE, MAPE, sesgo).",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "last_n_runs": {
+                    "type": "integer",
+                    "description": "Ejecuciones recientes a consultar.",
+                    "default": 5,
+                }
+            },
+        },
+    },
+    {
+        "name": "get_sales_summary",
+        "description": "Resumen de ventas agrupado por período, producto o canal.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "period": {
+                    "type": "string",
+                    "enum": ["week", "month", "quarter"],
+                    "description": "Período de agrupación.",
+                    "default": "month",
+                },
+                "group_by": {
+                    "type": "string",
+                    "enum": ["product", "channel", "region", "none"],
+                    "description": "Dimensión de agrupación adicional.",
+                    "default": "none",
+                },
+            },
+        },
+    },
+    {
+        "name": "get_inventory_status",
+        "description": "Estado actual del inventario por producto y nivel de riesgo de desabasto.",
+        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "import_excel_data",
+        "description": "Importa datos de ventas desde un archivo Excel plano. Usar cuando el usuario suba datos reales del negocio.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "Ruta al archivo Excel (.xlsx o .xls).",
+                },
+                "sheet_name": {
+                    "type": "string",
+                    "description": "Nombre de la hoja a importar (default: primera hoja).",
+                    "default": "Sheet1",
+                },
+            },
+            "required": ["file_path"],
+        },
+    },
+]
+
+
+def _get_demand_metrics(last_n_runs: int = 5) -> dict:
+    try:
+        db = get_supabase()
+        result = (
+            db.table("ml_model_runs")
+            .select("run_date, metrics, status, notes")
+            .eq("model_id", _get_demand_model_id())
+            .order("run_date", desc=True)
+            .limit(last_n_runs)
+            .execute()
+        )
+        if result.data:
+            return {"runs": result.data, "count": len(result.data)}
+        return {"message": "No hay ejecuciones del modelo de demanda registradas. Pendiente de entrenamiento (Fase 2)."}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _get_sales_summary(period: str = "month", group_by: str = "none") -> dict:
+    try:
+        db = get_supabase()
+        query = db.table("sales_data").select(
+            "date, product_name, product_category, quantity, total_amount, channel, region"
+        )
+
+        from datetime import datetime, timedelta
+        period_days = {"week": 7, "month": 30, "quarter": 90}
+        since = (datetime.utcnow() - timedelta(days=period_days.get(period, 30))).isoformat()
+        query = query.gte("date", since).order("date", desc=True)
+        result = query.execute()
+
+        if not result.data:
+            return {
+                "message": f"No hay datos de ventas para el período '{period}'. "
+                           "Los datos reales se cargarán en Fase 2 vía Excel o dataset Kaggle."
+            }
+
+        total_amount = sum(r.get("total_amount", 0) or 0 for r in result.data)
+        total_qty = sum(r.get("quantity", 0) or 0 for r in result.data)
+        return {
+            "period": period,
+            "group_by": group_by,
+            "total_records": len(result.data),
+            "total_amount_usd": round(total_amount, 2),
+            "total_quantity": round(total_qty, 2),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _get_inventory_status() -> dict:
+    try:
+        db = get_supabase()
+        result = db.table("inventory_status").select("*").execute()
+        if result.data:
+            return {"inventory": result.data}
+        return {"message": "Tabla de inventario vacía. Se poblará en Fase 2 con datos reales."}
+    except Exception as e:
+        return {"message": "Inventario no disponible aún. Pendiente Fase 2.", "error": str(e)}
+
+
+def _import_excel_data(file_path: str, sheet_name: str = "Sheet1") -> dict:
+    """
+    Importa datos de ventas desde Excel plano.
+    Diseñado para la base de datos real del negocio (aceites, mantecas, etc.).
+    """
+    try:
+        import pandas as pd
+
+        df = pd.read_excel(file_path, sheet_name=sheet_name)
+        logger.info(f"[demand_monitor] Excel cargado: {len(df)} filas, columnas: {list(df.columns)}")
+
+        # Normalización básica de columnas comunes
+        col_map = {
+            "fecha": "date", "date": "date",
+            "producto": "product_name", "product": "product_name",
+            "categoria": "product_category", "category": "product_category",
+            "cantidad": "quantity", "qty": "quantity",
+            "precio": "unit_price", "price": "unit_price",
+            "total": "total_amount", "monto": "total_amount",
+            "canal": "channel", "region": "region", "región": "region",
+        }
+        df.columns = [col_map.get(c.lower().strip(), c.lower().strip()) for c in df.columns]
+
+        records = df.to_dict(orient="records")
+
+        db = get_supabase()
+        # Insertar en lotes de 100
+        batch_size = 100
+        inserted = 0
+        for i in range(0, len(records), batch_size):
+            batch = records[i : i + batch_size]
+            db.table("sales_data").upsert(batch).execute()
+            inserted += len(batch)
+
+        return {
+            "success": True,
+            "rows_imported": inserted,
+            "columns_detected": list(df.columns),
+            "file": file_path,
+        }
+    except Exception as e:
+        logger.error(f"[demand_monitor] error importando Excel: {e}")
+        return {"error": str(e)}
+
+
+def _get_demand_model_id() -> str:
+    try:
+        db = get_supabase()
+        result = db.table("ml_models").select("id").eq("type", "demand_forecast").execute()
+        if result.data:
+            return result.data[0]["id"]
+    except Exception:
+        pass
+    return "00000000-0000-0000-0000-000000000001"
+
+
+TOOL_HANDLERS = {
+    "get_demand_metrics": _get_demand_metrics,
+    "get_sales_summary": _get_sales_summary,
+    "get_inventory_status": _get_inventory_status,
+    "import_excel_data": _import_excel_data,
+}
+
+
+class DemandMonitorAgent:
+    """Agente de monitoreo del modelo de forecasting de demanda y ventas."""
+
+    def run(self, message: str, session_history: list | None = None) -> tuple[str, list]:
+        return run_agent(
+            system_prompt=SYSTEM_PROMPT,
+            user_message=message,
+            tools=TOOLS,
+            tool_handlers=TOOL_HANDLERS,
+            model=MODEL_SMART,
+            conversation_history=session_history,
+        )

agents/specialists/price_monitor.py

@@ -0,0 +1,197 @@
+"""
+price_monitor.py
+----------------
+Agente especialista: monitoreo del modelo de forecasting de precios
+del aceite de palma (datos FRED / World Bank).
+
+Herramientas disponibles:
+  - get_latest_price_metrics   Últimas métricas del modelo (MAE, RMSE, MAPE)
+  - get_price_history          Serie histórica de precios
+  - detect_price_anomalies     Detecta anomalías en predicciones recientes
+  - get_model_drift_status     Estado de drift del modelo
+"""
+
+import logging
+from agents.base_agent import run_agent, MODEL_SMART
+from database.supabase_client import get_supabase
+
+logger = logging.getLogger(__name__)
+
+SYSTEM_PROMPT = """Eres el agente monitor del modelo de forecasting de precios del aceite de palma.
+
+Tu rol:
+- Reportar el estado actual del modelo de predicción de precios
+- Detectar y alertar sobre anomalías, drift de datos o degradación de métricas
+- Explicar las tendencias de precio y su impacto en el negocio
+- Sugerir acciones cuando el modelo necesita reentrenamiento
+
+El negocio es una empresa ecuatoriana de producción y venta de aceites comestibles y mantecas.
+El precio mundial del aceite de palma (USD/tonelada métrica) es el insumo principal del modelo.
+Fuentes de datos: FRED (PPOILUSDM), World Bank Pink Sheet, CFN Ecuador, ANCUPA.
+
+Cuando reportes métricas, sé específico con números. Cuando detectes problemas, prioriza claridad.
+Responde siempre en español."""
+
+# Definiciones de herramientas
+TOOLS = [
+    {
+        "name": "get_latest_price_metrics",
+        "description": "Obtiene las últimas métricas de rendimiento del modelo de forecasting de precios (MAE, RMSE, MAPE, R²).",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "last_n_runs": {
+                    "type": "integer",
+                    "description": "Número de ejecuciones recientes a consultar (default: 5).",
+                    "default": 5,
+                }
+            },
+        },
+    },
+    {
+        "name": "get_price_history",
+        "description": "Obtiene la serie histórica de precios del aceite de palma y las predicciones del modelo.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "months": {
+                    "type": "integer",
+                    "description": "Meses hacia atrás a consultar (default: 12).",
+                    "default": 12,
+                }
+            },
+        },
+    },
+    {
+        "name": "detect_price_anomalies",
+        "description": "Analiza las predicciones recientes y detecta anomalías o desviaciones inusuales.",
+        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "get_model_drift_status",
+        "description": "Evalúa si hay drift en los datos de entrada o en la distribución de predicciones del modelo.",
+        "input_schema": {"type": "object", "properties": {}},
+    },
+]
+
+
+# Handlers de herramientas
+def _get_latest_price_metrics(last_n_runs: int = 5) -> dict:
+    """Consulta métricas del modelo en Supabase."""
+    try:
+        db = get_supabase()
+        result = (
+            db.table("ml_model_runs")
+            .select("run_date, metrics, status, notes")
+            .eq("model_id", _get_price_model_id())
+            .order("run_date", desc=True)
+            .limit(last_n_runs)
+            .execute()
+        )
+        if result.data:
+            return {"runs": result.data, "count": len(result.data)}
+        return {"message": "No hay ejecuciones registradas aún. El modelo no ha sido entrenado todavía."}
+    except Exception as e:
+        logger.error(f"[price_monitor] error consultando métricas: {e}")
+        return {"error": str(e), "message": "No se pudieron obtener las métricas. Verifica la conexión a Supabase."}
+
+
+def _get_price_history(months: int = 12) -> dict:
+    """Consulta histórico de precios en Supabase."""
+    try:
+        db = get_supabase()
+        from datetime import datetime, timedelta
+        since = (datetime.utcnow() - timedelta(days=months * 30)).isoformat()
+        result = (
+            db.table("price_data")
+            .select("date, actual_price, predicted_price, source")
+            .gte("date", since)
+            .order("date", desc=False)
+            .execute()
+        )
+        if result.data:
+            return {"records": result.data, "count": len(result.data), "months": months}
+        return {"message": f"No hay datos de precios para los últimos {months} meses. Pendiente de cargar datos de FRED/World Bank."}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _detect_price_anomalies() -> dict:
+    """Detección simple de anomalías en predicciones recientes."""
+    try:
+        db = get_supabase()
+        result = (
+            db.table("price_data")
+            .select("date, actual_price, predicted_price")
+            .order("date", desc=True)
+            .limit(30)
+            .execute()
+        )
+        if not result.data:
+            return {"message": "No hay datos suficientes para detectar anomalías."}
+
+        anomalies = []
+        for row in result.data:
+            if row.get("actual_price") and row.get("predicted_price"):
+                error_pct = abs(row["actual_price"] - row["predicted_price"]) / row["actual_price"] * 100
+                if error_pct > 15:  # Umbral: 15% de error
+                    anomalies.append({
+                        "date": row["date"],
+                        "actual": row["actual_price"],
+                        "predicted": row["predicted_price"],
+                        "error_pct": round(error_pct, 2),
+                    })
+        return {"anomalies": anomalies, "total_checked": len(result.data)}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _get_model_drift_status() -> dict:
+    """Estado de drift del modelo (placeholder hasta tener modelo real)."""
+    try:
+        db = get_supabase()
+        result = (
+            db.table("ml_models")
+            .select("name, metrics, last_evaluated")
+            .eq("type", "price_forecast")
+            .execute()
+        )
+        if result.data:
+            return {"model": result.data[0]}
+        return {"message": "Modelo de forecasting de precios aún no registrado. Fase 2 del proyecto."}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def _get_price_model_id() -> str:
+    """Obtiene el ID del modelo de precios en Supabase."""
+    try:
+        db = get_supabase()
+        result = db.table("ml_models").select("id").eq("type", "price_forecast").execute()
+        if result.data:
+            return result.data[0]["id"]
+    except Exception:
+        pass
+    return "00000000-0000-0000-0000-000000000000"  # Placeholder
+
+
+TOOL_HANDLERS = {
+    "get_latest_price_metrics": _get_latest_price_metrics,
+    "get_price_history": _get_price_history,
+    "detect_price_anomalies": _detect_price_anomalies,
+    "get_model_drift_status": _get_model_drift_status,
+}
+
+
+class PriceMonitorAgent:
+    """Agente de monitoreo del modelo de forecasting de precios."""
+
+    def run(self, message: str, session_history: list | None = None) -> tuple[str, list]:
+        return run_agent(
+            system_prompt=SYSTEM_PROMPT,
+            user_message=message,
+            tools=TOOLS,
+            tool_handlers=TOOL_HANDLERS,
+            model=MODEL_SMART,
+            conversation_history=session_history,
+        )

app.py

@@ -0,0 +1,236 @@
+"""
+app.py
+------
+Entry point del HuggingFace Space.
+Combina:
+  - FastAPI: webhook de Telegram (/telegram-webhook)
+  - Gradio: dashboard de monitoreo (montado en /)
+
+Para ejecutar localmente:
+    python app.py
+
+Para configurar el webhook de Telegram (una sola vez):
+    python telegram/bot.py --setup
+"""
+
+import os
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+
+from dotenv import load_dotenv
+load_dotenv()
+
+import gradio as gr
+from fastapi import FastAPI, Request, Response
+import uvicorn
+
+# ── Agentes ───────────────────────────────────────────────
+from agents.orchestrator import Orchestrator
+from agents.specialists.price_monitor import PriceMonitorAgent
+from agents.specialists.demand_monitor import DemandMonitorAgent
+from agents.agent_lab import AgentLabAgent
+from telegram.bot import TelegramBot
+
+logging.basicConfig(
+    level=os.environ.get("LOG_LEVEL", "INFO"),
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ── Inicialización de agentes ─────────────────────────────
+orchestrator = Orchestrator()
+agent_map = {
+    "price_monitor": PriceMonitorAgent(),
+    "demand_monitor": DemandMonitorAgent(),
+    "agent_lab": AgentLabAgent(),
+}
+telegram_bot = TelegramBot(orchestrator=orchestrator, agent_map=agent_map)
+
+# ── FastAPI ───────────────────────────────────────────────
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("monitor-ml-aceitess iniciado")
+    yield
+    logger.info("monitor-ml-aceitess detenido")
+
+fastapi_app = FastAPI(
+    title="monitor-ml-aceitess",
+    description="Sistema multiagente de monitoreo ML para aceites comestibles",
+    lifespan=lifespan,
+)
+
+
+@fastapi_app.post("/telegram-webhook")
+async def telegram_webhook(request: Request):
+    """Recibe updates de Telegram vía webhook."""
+    try:
+        data = await request.json()
+        asyncio.create_task(telegram_bot.process_update(data))
+        return Response(content="ok", status_code=200)
+    except Exception as e:
+        logger.error(f"[webhook] error: {e}")
+        return Response(content="error", status_code=500)
+
+
+@fastapi_app.get("/health")
+def health():
+    """Endpoint de salud para UptimeRobot."""
+    return {"status": "ok", "service": "monitor-ml-aceitess"}
+
+
+# ── Gradio Dashboard ──────────────────────────────────────
+def build_dashboard() -> gr.Blocks:
+    with gr.Blocks(
+        title="Monitor ML — Aceites",
+        theme=gr.themes.Soft(),
+        css=".gradio-container { max-width: 900px; margin: auto; }",
+    ) as demo:
+
+        gr.Markdown("# Monitor ML — Aceites Comestibles")
+        gr.Markdown(
+            "Sistema multiagente para monitoreo de modelos de forecasting de "
+            "precios y demanda de aceites comestibles (Ecuador)."
+        )
+
+        with gr.Tabs():
+
+            # ── Tab: Chat con agentes ──────────────────────
+            with gr.TabItem("Chat con Agentes"):
+                gr.Markdown("Consulta directamente a los agentes especialistas.")
+
+                chatbot = gr.Chatbot(height=400, label="Conversación")
+                with gr.Row():
+                    msg_input = gr.Textbox(
+                        placeholder="Ej: ¿Cuál es el estado del modelo de precios?",
+                        label="Mensaje",
+                        scale=4,
+                    )
+                    send_btn = gr.Button("Enviar", variant="primary", scale=1)
+
+                session_state = gr.State([])
+
+                def chat(message: str, history: list, session: list):
+                    if not message.strip():
+                        return history, session, ""
+
+                    agent_name = orchestrator.classify(message)
+                    agent = agent_map.get(agent_name)
+
+                    if agent:
+                        response, updated_session = agent.run(message, session[-20:])
+                    else:
+                        response = f"Agente '{agent_name}' no disponible."
+                        updated_session = session
+
+                    history.append((message, f"[{agent_name}] {response}"))
+                    return history, updated_session, ""
+
+                send_btn.click(
+                    chat,
+                    inputs=[msg_input, chatbot, session_state],
+                    outputs=[chatbot, session_state, msg_input],
+                )
+                msg_input.submit(
+                    chat,
+                    inputs=[msg_input, chatbot, session_state],
+                    outputs=[chatbot, session_state, msg_input],
+                )
+
+            # ── Tab: Estado del sistema ────────────────────
+            with gr.TabItem("Estado del Sistema"):
+                gr.Markdown("### Agentes registrados")
+
+                def get_system_status():
+                    stats = orchestrator.get_stats()
+                    rows = [[name, count, "✅ activo"] for name, count in stats.items()]
+                    return rows
+
+                status_table = gr.Dataframe(
+                    headers=["Agente", "Consultas", "Estado"],
+                    value=get_system_status(),
+                    interactive=False,
+                )
+                refresh_btn = gr.Button("Actualizar")
+                refresh_btn.click(get_system_status, outputs=status_table)
+
+            # ── Tab: Recomendaciones Agent Lab ─────────────
+            with gr.TabItem("Recomendaciones Agent Lab"):
+                gr.Markdown(
+                    "Recomendaciones proactivas generadas por Agent Lab "
+                    "que requieren aprobación humana."
+                )
+
+                def get_recommendations():
+                    try:
+                        from database.supabase_client import get_supabase
+                        db = get_supabase()
+                        result = (
+                            db.table("agent_lab_recommendations")
+                            .select("title, target_agent, type, status, priority, created_at")
+                            .order("created_at", desc=True)
+                            .limit(20)
+                            .execute()
+                        )
+                        if result.data:
+                            return [[
+                                r["title"], r["target_agent"], r["type"],
+                                r["status"], r["priority"], r["created_at"][:10]
+                            ] for r in result.data]
+                    except Exception as e:
+                        logger.warning(f"No se pudieron cargar recomendaciones: {e}")
+                    return [["Sin datos", "—", "—", "—", "—", "—"]]
+
+                rec_table = gr.Dataframe(
+                    headers=["Título", "Agente", "Tipo", "Estado", "Prioridad", "Fecha"],
+                    value=get_recommendations(),
+                    interactive=False,
+                )
+                refresh_rec_btn = gr.Button("Actualizar")
+                refresh_rec_btn.click(get_recommendations, outputs=rec_table)
+
+            # ── Tab: Info ──────────────────────────────────
+            with gr.TabItem("Acerca de"):
+                gr.Markdown("""
+## monitor-ml-aceitess
+
+Sistema multiagente basado en Claude (Anthropic) para monitoreo de modelos ML
+aplicados a la producción y venta de aceites comestibles en Ecuador.
+
+### Agentes
+| Agente | Rol |
+|--------|-----|
+| `price_monitor` | Forecasting de precios del aceite de palma (FRED/World Bank) |
+| `demand_monitor` | Forecasting de demanda y ventas (aceites, mantecas) |
+| `agent_lab` | Meta-agente de auto-mejora continua |
+| `orchestrator` | Clasificación de intents y routing |
+
+### Fuentes de datos
+- **Precio palma**: FRED (PPOILUSDM), World Bank Pink Sheet, CFN Ecuador
+- **Ventas**: FMCG Kaggle (proxy) → datos reales del negocio en Excel (Fase 2)
+- **Ecuador**: ANCUPA, USDA FAS PSD Online
+
+### Arquitectura
+Desplegado en HuggingFace Spaces (Gradio + FastAPI).
+Interfaz principal vía Telegram bot (webhook).
+Base de datos: Supabase.
+Cron diario de research: GitHub Actions.
+                """)
+
+    return demo
+
+
+# ── Montar Gradio sobre FastAPI ───────────────────────────
+dashboard = build_dashboard()
+app = gr.mount_gradio_app(fastapi_app, dashboard, path="/")
+
+
+# ── Punto de entrada local ────────────────────────────────
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=port,
+        reload=os.environ.get("APP_ENV") == "development",
+    )

cron/research_pipeline.py

@@ -0,0 +1,247 @@
+"""
+research_pipeline.py
+--------------------
+Pipeline diario de investigación. Ejecutado por GitHub Actions cada noche.
+
+Pasos:
+  1. SCRAPE  — Fetch RSS/HTML de 6 fuentes de AI research
+  2. DEDUP   — Filtrar URLs ya procesadas en DB
+  3. SCORE   — Haiku evalúa relevancia para el dominio (0.0 a 1.0)
+  4. SAVE    — Guardar findings con score > 0.3
+  5. BLOAT   — Verificar skill bloat en agentes
+  6. IMPROVE — Agent Lab ejecuta ciclo completo de mejora
+  7. REPORT  — Enviar resumen vía Telegram
+
+Uso:
+    python -m cron.research_pipeline
+    python -m cron.research_pipeline --dry-run   (sin escribir a DB)
+"""
+
+import os
+import sys
+import asyncio
+import logging
+import argparse
+from datetime import datetime
+
+import httpx
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# Fuentes de research
+RESEARCH_SOURCES = [
+    {"name": "Anthropic Blog",    "url": "https://www.anthropic.com/news", "tier": "anthropic"},
+    {"name": "Anthropic Cookbook","url": "https://github.com/anthropics/anthropic-cookbook/commits/main.atom", "tier": "anthropic"},
+    {"name": "Simon Willison",    "url": "https://simonwillison.net/atom/entries/", "tier": "community"},
+    {"name": "Lilian Weng",       "url": "https://lilianweng.github.io/index.xml", "tier": "research"},
+    {"name": "LangChain Blog",    "url": "https://blog.langchain.dev/rss/", "tier": "ecosystem"},
+    {"name": "HuggingFace Blog",  "url": "https://huggingface.co/blog/feed.xml", "tier": "ecosystem"},
+]
+
+RELEVANCE_PROMPT = """Eres un evaluador de relevancia para un sistema de agentes de monitoreo ML
+aplicado a la industria de aceites comestibles en Ecuador.
+
+El sistema usa:
+- Claude (Anthropic) como LLM
+- Agentes especialistas con tool-calling
+- Forecasting de precios de aceite de palma y demanda de ventas
+- Python, Supabase, HuggingFace Spaces, Telegram
+
+Evalúa este artículo con un score de 0.0 a 1.0 de relevancia para MEJORAR el sistema:
+- >0.8: Específico y directamente aplicable (nueva técnica de agentes, mejora de tool-calling, etc.)
+- >0.5: Relevante pero genérico (mejores prácticas de LLM, patrones de agentes)
+- <0.3: Irrelevante para este sistema
+
+Responde SOLO con el número (ej: 0.75). Sin texto adicional.
+
+Artículo:
+Título: {title}
+Resumen: {summary}"""
+
+
+async def scrape_rss(url: str) -> list[dict]:
+    """Obtiene entradas de un feed RSS/Atom."""
+    try:
+        import xml.etree.ElementTree as ET
+
+        async with httpx.AsyncClient(timeout=15, follow_redirects=True) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+
+        root = ET.fromstring(response.text)
+        ns = {"atom": "http://www.w3.org/2005/Atom"}
+
+        entries = []
+
+        # Atom feed
+        for entry in root.findall(".//atom:entry", ns):
+            title_el = entry.find("atom:title", ns)
+            link_el = entry.find("atom:link", ns)
+            summary_el = entry.find("atom:summary", ns) or entry.find("atom:content", ns)
+
+            if title_el is not None and link_el is not None:
+                entries.append({
+                    "title": title_el.text or "",
+                    "url": link_el.get("href", ""),
+                    "summary": (summary_el.text or "")[:500] if summary_el is not None else "",
+                })
+
+        # RSS 2.0 feed
+        if not entries:
+            for item in root.findall(".//item"):
+                title_el = item.find("title")
+                link_el = item.find("link")
+                desc_el = item.find("description")
+
+                if title_el is not None and link_el is not None:
+                    entries.append({
+                        "title": title_el.text or "",
+                        "url": link_el.text or "",
+                        "summary": (desc_el.text or "")[:500] if desc_el is not None else "",
+                    })
+
+        return entries[:10]  # Máximo 10 por fuente
+
+    except Exception as e:
+        logger.warning(f"Error scrapeando {url}: {e}")
+        return []
+
+
+async def score_relevance(title: str, summary: str) -> float:
+    """Usa Haiku para evaluar relevancia del artículo."""
+    import anthropic
+    try:
+        client = anthropic.Anthropic()
+        response = client.messages.create(
+            model="claude-haiku-4-5-20251001",
+            max_tokens=10,
+            messages=[{
+                "role": "user",
+                "content": RELEVANCE_PROMPT.format(title=title, summary=summary[:300]),
+            }],
+        )
+        score_text = response.content[0].text.strip()
+        return min(max(float(score_text), 0.0), 1.0)
+    except Exception as e:
+        logger.warning(f"Error evaluando relevancia: {e}")
+        return 0.0
+
+
+async def run_pipeline(dry_run: bool = False):
+    """Ejecuta el pipeline completo de investigación."""
+    logger.info("=== Iniciando pipeline de research ===")
+    start_time = datetime.utcnow()
+
+    from database.supabase_client import get_supabase
+    db = get_supabase() if not dry_run else None
+
+    # 1. SCRAPE
+    logger.info("PASO 1: Scraping de fuentes...")
+    all_entries = []
+    for source in RESEARCH_SOURCES:
+        entries = await scrape_rss(source["url"])
+        for e in entries:
+            e["source_tier"] = source["tier"]
+            e["source_name"] = source["name"]
+        all_entries.extend(entries)
+        logger.info(f"  {source['name']}: {len(entries)} entradas")
+
+    logger.info(f"Total entradas scraped: {len(all_entries)}")
+
+    # 2. DEDUP
+    logger.info("PASO 2: Deduplicación...")
+    if db:
+        existing = db.table("agent_lab_research").select("source_url").execute()
+        existing_urls = {r["source_url"] for r in (existing.data or [])}
+        all_entries = [e for e in all_entries if e["url"] not in existing_urls]
+    logger.info(f"Entradas nuevas después de dedup: {len(all_entries)}")
+
+    # 3. SCORE + 4. SAVE
+    logger.info("PASO 3-4: Scoring y guardado...")
+    saved = 0
+    for entry in all_entries:
+        score = await score_relevance(entry["title"], entry["summary"])
+        logger.debug(f"  Score {score:.2f}: {entry['title'][:60]}")
+
+        if score > 0.3:
+            if not dry_run and db:
+                db.table("agent_lab_research").insert({
+                    "source_url": entry["url"],
+                    "source_tier": entry["source_tier"],
+                    "title": entry["title"],
+                    "summary": entry["summary"],
+                    "relevance_score": round(score, 2),
+                    "tags": [entry["source_tier"]],
+                }).execute()
+            saved += 1
+
+    logger.info(f"Findings guardados (score > 0.3): {saved}")
+
+    # 5. BLOAT CHECK
+    logger.info("PASO 5: Verificando skill bloat...")
+    if db:
+        agents = db.table("agents").select("name, tools").execute()
+        for agent in (agents.data or []):
+            tool_count = len(agent.get("tools") or [])
+            if tool_count >= 5:
+                logger.warning(f"  BLOAT: {agent['name']} tiene {tool_count} herramientas")
+
+    # 6. AGENT LAB
+    logger.info("PASO 6: Ejecutando ciclo de Agent Lab...")
+    if not dry_run:
+        from agents.agent_lab import AgentLabAgent
+        lab = AgentLabAgent()
+        lab_report = lab.run_daily_cycle()
+        logger.info(f"Agent Lab completado: {lab_report[:200]}...")
+    else:
+        lab_report = "[dry-run: Agent Lab omitido]"
+
+    # 7. REPORT
+    elapsed = (datetime.utcnow() - start_time).seconds
+    report = (
+        f"📊 *Reporte diario Agent Lab*\n\n"
+        f"• Fuentes scrapeadas: {len(RESEARCH_SOURCES)}\n"
+        f"• Entradas procesadas: {len(all_entries)}\n"
+        f"• Findings guardados: {saved}\n"
+        f"• Duración: {elapsed}s\n\n"
+        f"*Resumen Agent Lab:*\n{lab_report[:500]}"
+    )
+
+    await send_telegram_report(report)
+    logger.info("=== Pipeline completado ===")
+    return report
+
+
+async def send_telegram_report(message: str):
+    """Envía el reporte al bot de Telegram."""
+    token = os.environ.get("TELEGRAM_BOT_TOKEN")
+    chat_id = os.environ.get("TELEGRAM_ADMIN_CHAT_ID")
+
+    if not token or not chat_id:
+        logger.info(f"[Report] (Telegram no configurado)\n{message}")
+        return
+
+    try:
+        async with httpx.AsyncClient() as client:
+            await client.post(
+                f"https://api.telegram.org/bot{token}/sendMessage",
+                json={"chat_id": chat_id, "text": message, "parse_mode": "Markdown"},
+            )
+        logger.info("Reporte enviado por Telegram")
+    except Exception as e:
+        logger.error(f"Error enviando reporte Telegram: {e}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Pipeline diario de research")
+    parser.add_argument("--dry-run", action="store_true", help="Ejecutar sin escribir a DB")
+    args = parser.parse_args()
+
+    asyncio.run(run_pipeline(dry_run=args.dry_run))

database/__init__.py

@@ -0,0 +1,3 @@
+from database.supabase_client import get_supabase
+
+__all__ = ["get_supabase"]

database/schema.sql

@@ -0,0 +1,194 @@
+-- ============================================================
+-- schema.sql — monitor-ml-aceitess
+-- Ejecutar en el SQL Editor de Supabase (una sola vez)
+-- ============================================================
+
+-- ─── Extensiones ──────────────────────────────────────────
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+
+-- ─── Agentes ──────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS agents (
+    id            UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    name          VARCHAR(100) UNIQUE NOT NULL,
+    description   TEXT,
+    system_prompt TEXT NOT NULL DEFAULT '',
+    model         VARCHAR(100) DEFAULT 'claude-sonnet-4-6',
+    tools         JSONB DEFAULT '[]',
+    skills        JSONB DEFAULT '[]',
+    memory        JSONB DEFAULT '{}',
+    version_hash  VARCHAR(64),
+    created_at    TIMESTAMPTZ DEFAULT NOW(),
+    updated_at    TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- ─── Sesiones de conversación ─────────────────────────────
+CREATE TABLE IF NOT EXISTS sessions (
+    id               UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    telegram_user_id BIGINT NOT NULL,
+    agent_name       VARCHAR(100),
+    history          JSONB DEFAULT '[]',
+    created_at       TIMESTAMPTZ DEFAULT NOW(),
+    updated_at       TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions (telegram_user_id);
+
+-- ─── Modelos ML ───────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS ml_models (
+    id             UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    name           VARCHAR(100) UNIQUE NOT NULL,
+    type           VARCHAR(50) NOT NULL,   -- 'price_forecast' | 'demand_forecast'
+    description    TEXT,
+    metrics        JSONB DEFAULT '{}',     -- MAE, RMSE, MAPE, R², etc.
+    last_evaluated TIMESTAMPTZ,
+    created_at     TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Insertar modelos base
+INSERT INTO ml_models (name, type, description) VALUES
+    ('palm_price_forecast', 'price_forecast', 'Forecasting de precio mundial aceite de palma (FRED/World Bank)'),
+    ('sales_demand_forecast', 'demand_forecast', 'Forecasting de demanda y ventas de aceites y mantecas')
+ON CONFLICT (name) DO NOTHING;
+
+-- ─── Ejecuciones de modelos ML ────────────────────────────
+CREATE TABLE IF NOT EXISTS ml_model_runs (
+    id              UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    model_id        UUID REFERENCES ml_models(id) ON DELETE CASCADE,
+    run_date        TIMESTAMPTZ DEFAULT NOW(),
+    metrics         JSONB NOT NULL DEFAULT '{}',
+    data_source     VARCHAR(100),
+    rows_processed  INTEGER,
+    status          VARCHAR(20) DEFAULT 'success' CHECK (status IN ('success', 'failed', 'warning')),
+    notes           TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_model_runs_model ON ml_model_runs (model_id, run_date DESC);
+
+-- ─── Serie de precios (aceite de palma) ───────────────────
+CREATE TABLE IF NOT EXISTS price_data (
+    id              UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    date            DATE NOT NULL,
+    actual_price    DECIMAL(10,2),         -- USD/tonelada métrica
+    predicted_price DECIMAL(10,2),
+    source          VARCHAR(50),           -- 'FRED' | 'WorldBank' | 'CFN' | 'ANCUPA'
+    currency        VARCHAR(3) DEFAULT 'USD',
+    unit            VARCHAR(20) DEFAULT 'USD/MT',
+    created_at      TIMESTAMPTZ DEFAULT NOW(),
+    UNIQUE (date, source)
+);
+CREATE INDEX IF NOT EXISTS idx_price_data_date ON price_data (date DESC);
+
+-- ─── Datos de ventas ──────────────────────────────────────
+-- Diseñado para recibir datos reales del negocio (Excel plano en el futuro)
+CREATE TABLE IF NOT EXISTS sales_data (
+    id               UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    source_id        UUID,                  -- referencia a data_sources
+    date             DATE NOT NULL,
+    product_name     VARCHAR(200),
+    product_category VARCHAR(100),          -- 'aceite', 'manteca', 'otros'
+    quantity         DECIMAL(10,2),
+    unit_price       DECIMAL(10,2),
+    total_amount     DECIMAL(10,2),
+    currency         VARCHAR(3) DEFAULT 'USD',
+    region           VARCHAR(100),
+    channel          VARCHAR(50),           -- 'retail', 'wholesale', 'ecommerce'
+    metadata         JSONB DEFAULT '{}',   -- columnas extra del Excel original
+    created_at       TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_sales_date ON sales_data (date DESC);
+CREATE INDEX IF NOT EXISTS idx_sales_category ON sales_data (product_category);
+
+-- ─── Inventario ──���────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS inventory_status (
+    id               UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    product_name     VARCHAR(200) NOT NULL,
+    product_category VARCHAR(100),
+    current_stock    DECIMAL(10,2),
+    unit             VARCHAR(20) DEFAULT 'kg',
+    reorder_point    DECIMAL(10,2),
+    risk_level       VARCHAR(20) DEFAULT 'ok' CHECK (risk_level IN ('ok', 'low', 'critical')),
+    updated_at       TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- ─── Fuentes de datos ─────────────────────────────────────
+CREATE TABLE IF NOT EXISTS data_sources (
+    id           UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    name         VARCHAR(100) NOT NULL,
+    type         VARCHAR(50),               -- 'kaggle' | 'fred' | 'world_bank' | 'excel_import' | 'ancupa'
+    description  TEXT,
+    url          TEXT,
+    last_updated TIMESTAMPTZ,
+    rows_count   INTEGER,
+    columns      JSONB DEFAULT '[]',
+    metadata     JSONB DEFAULT '{}',
+    created_at   TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Insertar fuentes conocidas
+INSERT INTO data_sources (name, type, description, url) VALUES
+    ('FRED PPOILUSDM', 'fred', 'Precio mundial aceite de palma mensual (IMF vía FRED)', 'https://fred.stlouisfed.org/series/PPOILUSDM'),
+    ('World Bank Pink Sheet', 'world_bank', 'Commodities price data mensual desde 1960', 'https://thedocs.worldbank.org/en/doc/18675f1d1639c7a34d463f59263ba0a2-0050012025/world-bank-commodities-price-data-the-pink-sheet'),
+    ('FMCG Daily Sales 2022-2024', 'kaggle', 'Ventas diarias FMCG sintéticas (proxy hasta tener datos reales)', 'https://www.kaggle.com/datasets/beatafaron/fmcg-daily-sales-data-to-2022-2024'),
+    ('CFN Ficha Sectorial Palma 2024', 'cfn_ecuador', 'Precios productor y estadísticas palma africana Ecuador 2024', 'https://www.cfn.fin.ec/wp-content/uploads/2024/07/Ficha-Sectorial-Palma-Africana.pdf'),
+    ('ANCUPA Ecuador', 'ancupa', 'Estadísticas nacionales palma aceitera Ecuador desde 1994', 'http://ancupa.com/estadisticas/')
+ON CONFLICT DO NOTHING;
+
+-- ─── Agent Lab: Research ──────────────────────────────────
+CREATE TABLE IF NOT EXISTS agent_lab_research (
+    id              UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    source_url      TEXT NOT NULL UNIQUE,
+    source_tier     VARCHAR(50),            -- 'anthropic' | 'huggingface' | 'langchain' | etc.
+    title           TEXT NOT NULL,
+    summary         TEXT,
+    relevance_score DECIMAL(3,2) DEFAULT 0.00 CHECK (relevance_score BETWEEN 0 AND 1),
+    tags            JSONB DEFAULT '[]',
+    created_at      TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_research_score ON agent_lab_research (relevance_score DESC);
+
+-- ─── Agent Lab: Recomendaciones ───────────────────────────
+CREATE TABLE IF NOT EXISTS agent_lab_recommendations (
+    id           UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    type         VARCHAR(20) NOT NULL CHECK (type IN ('reactive', 'proactive')),
+    category     VARCHAR(100),              -- 'prompt' | 'tool' | 'model' | 'skill' | 'memory'
+    target_agent VARCHAR(100) NOT NULL,
+    title        TEXT NOT NULL,
+    description  TEXT,
+    rationale    TEXT,
+    status       VARCHAR(20) DEFAULT 'pending' CHECK (status IN ('pending', 'approved', 'rejected', 'applied')),
+    priority     INTEGER DEFAULT 5 CHECK (priority BETWEEN 1 AND 10),
+    created_at   TIMESTAMPTZ DEFAULT NOW(),
+    updated_at   TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_recommendations_status ON agent_lab_recommendations (status, type);
+
+-- ─── Agent Lab: Audit Log ─────────────────────────────────
+CREATE TABLE IF NOT EXISTS agent_lab_changes (
+    id                UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    recommendation_id UUID REFERENCES agent_lab_recommendations(id),
+    change_type       VARCHAR(20) CHECK (change_type IN ('auto', 'approved')),
+    target_agent      VARCHAR(100),
+    description       TEXT,
+    before_state      JSONB,
+    after_state       JSONB,
+    created_at        TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- ─── Triggers: updated_at automático ─────────────────────
+CREATE OR REPLACE FUNCTION update_updated_at()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER trg_agents_updated_at
+    BEFORE UPDATE ON agents
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
+
+CREATE TRIGGER trg_sessions_updated_at
+    BEFORE UPDATE ON sessions
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
+
+CREATE TRIGGER trg_recommendations_updated_at
+    BEFORE UPDATE ON agent_lab_recommendations
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();

database/supabase_client.py

@@ -0,0 +1,32 @@
+"""
+supabase_client.py
+------------------
+Cliente Supabase singleton. Se inicializa una sola vez con las variables de entorno.
+"""
+
+import os
+import logging
+from functools import lru_cache
+from supabase import create_client, Client
+
+logger = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=1)
+def get_supabase() -> Client:
+    """
+    Devuelve el cliente Supabase (singleton).
+    Llama a esta función en cualquier lugar del proyecto para acceder a la DB.
+    """
+    url = os.environ.get("SUPABASE_URL")
+    key = os.environ.get("SUPABASE_KEY")
+
+    if not url or not key:
+        raise RuntimeError(
+            "Faltan variables de entorno SUPABASE_URL y/o SUPABASE_KEY. "
+            "Copia .env.example a .env y completa los valores."
+        )
+
+    client = create_client(url, key)
+    logger.info("[Supabase] cliente inicializado correctamente")
+    return client

requirements.txt

@@ -0,0 +1,28 @@
+# Core
+anthropic>=0.40.0
+gradio>=4.44.0
+fastapi>=0.115.0
+uvicorn>=0.32.0
+python-dotenv>=1.0.0
+
+# Telegram
+python-telegram-bot>=21.0.0
+
+# Supabase
+supabase>=2.9.0
+
+# Data & ML
+pandas>=2.2.0
+numpy>=1.26.0
+scikit-learn>=1.5.0
+statsmodels>=0.14.0
+openpyxl>=3.1.0        # Lectura de archivos Excel (futuro: datos reales del negocio)
+xlrd>=2.0.1
+
+# HTTP
+httpx>=0.27.0
+aiohttp>=3.10.0
+
+# Utilidades
+python-dateutil>=2.9.0
+pydantic>=2.9.0

telegram/__init__.py

@@ -0,0 +1,3 @@
+from telegram.bot import TelegramBot
+
+__all__ = ["TelegramBot"]

telegram/bot.py

@@ -0,0 +1,260 @@
+"""
+bot.py
+------
+Integración con Telegram via webhook.
+El Space de HuggingFace expone el endpoint POST /telegram-webhook.
+Telegram envía cada mensaje a esa URL.
+
+Setup inicial (una sola vez):
+    python telegram/bot.py --setup
+
+Esto registra el webhook en Telegram apuntando a tu Space URL.
+"""
+
+import os
+import logging
+import asyncio
+import argparse
+from typing import Any
+
+import httpx
+from telegram import Update, Bot
+from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
+
+logger = logging.getLogger(__name__)
+
+TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN", "")
+WEBHOOK_URL = os.environ.get("TELEGRAM_WEBHOOK_URL", "")
+
+
+class TelegramBot:
+    """
+    Maneja mensajes de Telegram y los enruta al orquestador de agentes.
+    """
+
+    def __init__(self, orchestrator=None, agent_map: dict | None = None):
+        """
+        Args:
+            orchestrator: instancia de Orchestrator para clasificar intents
+            agent_map:    dict {nombre_agente: instancia_agente}
+        """
+        self.orchestrator = orchestrator
+        self.agent_map = agent_map or {}
+        self.sessions: dict[int, list] = {}  # user_id → historial de conversación
+
+    async def process_update(self, update_data: dict) -> str | None:
+        """
+        Procesa un update recibido desde el webhook de Telegram.
+        Devuelve la respuesta generada o None si no hay nada que responder.
+        """
+        try:
+            bot = Bot(token=TOKEN)
+            update = Update.de_json(update_data, bot)
+
+            if not update.message or not update.message.text:
+                return None
+
+            user_id = update.message.from_user.id
+            user_name = update.message.from_user.first_name or "usuario"
+            text = update.message.text.strip()
+
+            logger.info(f"[TelegramBot] mensaje de {user_name} ({user_id}): {text[:60]}")
+
+            # Comandos especiales
+            if text.startswith("/"):
+                response = await self._handle_command(text, user_id, user_name)
+            else:
+                response = await self._handle_message(text, user_id)
+
+            if response:
+                await bot.send_message(
+                    chat_id=update.message.chat_id,
+                    text=response,
+                    parse_mode="Markdown",
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"[TelegramBot] error procesando update: {e}")
+            return None
+
+    async def _handle_message(self, text: str, user_id: int) -> str:
+        """Enruta el mensaje al agente correcto y devuelve la respuesta."""
+        if not self.orchestrator:
+            return "Sistema no inicializado. Contacta al administrador."
+
+        # Clasificar intent
+        agent_name = self.orchestrator.classify(text)
+        agent = self.agent_map.get(agent_name)
+
+        if not agent:
+            return f"Agente '{agent_name}' no disponible en este momento."
+
+        # Obtener/crear historial de sesión
+        session_history = self.sessions.get(user_id, [])
+
+        # Ejecutar agente
+        response, updated_history = agent.run(text, session_history)
+
+        # Guardar historial (últimos 20 mensajes para no crecer infinito)
+        self.sessions[user_id] = updated_history[-20:]
+
+        return response
+
+    async def _handle_command(self, command: str, user_id: int, user_name: str) -> str:
+        """Maneja comandos especiales de Telegram."""
+        cmd = command.split()[0].lower()
+
+        if cmd == "/start":
+            return (
+                f"Hola {user_name}! 👋\n\n"
+                "Soy el monitor de ML para aceites comestibles.\n\n"
+                "Puedo ayudarte con:\n"
+                "• Precios del aceite de palma\n"
+                "• Forecasting de demanda y ventas\n"
+                "• Estado del sistema de agentes\n\n"
+                "¿Qué quieres consultar?"
+            )
+
+        elif cmd == "/help":
+            return (
+                "*Comandos disponibles:*\n\n"
+                "/start — Bienvenida\n"
+                "/help — Esta ayuda\n"
+                "/status — Estado del sistema\n"
+                "/pending — Recomendaciones pendientes de aprobación\n"
+                "/reset — Limpiar historial de conversación\n\n"
+                "*Consultas en lenguaje natural:*\n"
+                "• ¿Cuál es el precio actual del aceite de palma?\n"
+                "• ¿Cómo están las ventas del último mes?\n"
+                "• ¿Hay alguna anomalía en el modelo?"
+            )
+
+        elif cmd == "/status":
+            stats = self.orchestrator.get_stats() if self.orchestrator else {}
+            lines = ["*Estado del sistema:* ✅\n"]
+            lines.append("*Agentes activos:*")
+            for name, count in stats.items():
+                lines.append(f"  • {name}: {count} consultas")
+            return "\n".join(lines)
+
+        elif cmd == "/pending":
+            return await self._get_pending_recommendations()
+
+        elif cmd == "/reset":
+            self.sessions.pop(user_id, None)
+            return "Historial de conversación limpiado. ¿En qué puedo ayudarte?"
+
+        elif cmd.startswith("/approve_"):
+            rec_id = cmd.replace("/approve_", "")
+            return await self._approve_recommendation(rec_id)
+
+        elif cmd.startswith("/reject_"):
+            rec_id = cmd.replace("/reject_", "")
+            return await self._reject_recommendation(rec_id)
+
+        return f"Comando '{cmd}' no reconocido. Usa /help para ver los disponibles."
+
+    async def _get_pending_recommendations(self) -> str:
+        """Muestra las recomendaciones proactivas pendientes de aprobación."""
+        try:
+            from database.supabase_client import get_supabase
+            db = get_supabase()
+            result = (
+                db.table("agent_lab_recommendations")
+                .select("id, title, target_agent, priority, created_at")
+                .eq("status", "pending")
+                .eq("type", "proactive")
+                .order("priority", desc=True)
+                .limit(10)
+                .execute()
+            )
+
+            if not result.data:
+                return "No hay recomendaciones pendientes de aprobación."
+
+            lines = [f"*Recomendaciones pendientes ({len(result.data)}):*\n"]
+            for rec in result.data:
+                short_id = rec["id"][:8]
+                lines.append(
+                    f"📋 *{rec['title']}*\n"
+                    f"   Agente: {rec['target_agent']} | Prioridad: {rec['priority']}\n"
+                    f"   /approve_{short_id} | /reject_{short_id}\n"
+                )
+            return "\n".join(lines)
+
+        except Exception as e:
+            return f"Error consultando recomendaciones: {e}"
+
+    async def _approve_recommendation(self, rec_id_prefix: str) -> str:
+        try:
+            from database.supabase_client import get_supabase
+            db = get_supabase()
+            result = (
+                db.table("agent_lab_recommendations")
+                .select("id, title")
+                .ilike("id", f"{rec_id_prefix}%")
+                .execute()
+            )
+            if not result.data:
+                return f"Recomendación {rec_id_prefix} no encontrada."
+
+            rec = result.data[0]
+            db.table("agent_lab_recommendations").update(
+                {"status": "approved"}
+            ).eq("id", rec["id"]).execute()
+
+            return f"✅ Recomendación aprobada: *{rec['title']}*\nSe aplicará en el próximo ciclo de Agent Lab."
+        except Exception as e:
+            return f"Error aprobando recomendación: {e}"
+
+    async def _reject_recommendation(self, rec_id_prefix: str) -> str:
+        try:
+            from database.supabase_client import get_supabase
+            db = get_supabase()
+            result = (
+                db.table("agent_lab_recommendations")
+                .select("id, title")
+                .ilike("id", f"{rec_id_prefix}%")
+                .execute()
+            )
+            if not result.data:
+                return f"Recomendación {rec_id_prefix} no encontrada."
+
+            rec = result.data[0]
+            db.table("agent_lab_recommendations").update(
+                {"status": "rejected"}
+            ).eq("id", rec["id"]).execute()
+
+            return f"❌ Recomendación rechazada: *{rec['title']}*"
+        except Exception as e:
+            return f"Error rechazando recomendación: {e}"
+
+
+async def setup_webhook():
+    """Registra el webhook de Telegram apuntando al Space de HuggingFace."""
+    if not TOKEN or not WEBHOOK_URL:
+        print("ERROR: Configura TELEGRAM_BOT_TOKEN y TELEGRAM_WEBHOOK_URL en .env")
+        return
+
+    webhook_endpoint = f"{WEBHOOK_URL.rstrip('/')}/telegram-webhook"
+    url = f"https://api.telegram.org/bot{TOKEN}/setWebhook"
+
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(url, json={"url": webhook_endpoint})
+        data = resp.json()
+
+    if data.get("ok"):
+        print(f"✅ Webhook registrado: {webhook_endpoint}")
+    else:
+        print(f"❌ Error: {data}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--setup", action="store_true", help="Registrar webhook en Telegram")
+    args = parser.parse_args()
+
+    if args.setup:
+        asyncio.run(setup_webhook())

tools/__init__.py

@@ -0,0 +1,3 @@
+from tools.sub_agent_tool import create_sub_agent_tool, SubAgentRunner
+
+__all__ = ["create_sub_agent_tool", "SubAgentRunner"]

tools/sub_agent_tool.py

@@ -0,0 +1,88 @@
+"""
+sub_agent_tool.py
+-----------------
+Patrón subAgentTool(): permite que cualquier agente delegue tareas a otro agente
+como si fuera una llamada a herramienta. Es la base de la jerarquía de agentes.
+
+Uso:
+    # Definir la herramienta para el agente padre
+    tool_def = create_sub_agent_tool(
+        agent_name="price_monitor",
+        description="Monitorea el modelo de forecasting de precios de aceite de palma."
+    )
+
+    # Crear el handler que ejecuta el sub-agente
+    runner = SubAgentRunner(agent_name="price_monitor", system_prompt=PRICE_MONITOR_PROMPT)
+    handler = runner.as_handler()
+"""
+
+import logging
+from typing import Callable
+from agents.base_agent import run_agent, MODEL_SMART
+
+logger = logging.getLogger(__name__)
+
+
+def create_sub_agent_tool(agent_name: str, description: str) -> dict:
+    """
+    Crea la definición de herramienta Anthropic para invocar un sub-agente.
+
+    Args:
+        agent_name:   Nombre del agente (usado como nombre de la tool).
+        description:  Descripción de lo que hace el agente (el modelo usará esto para decidir cuándo llamarlo).
+
+    Returns:
+        Definición de herramienta en formato Anthropic.
+    """
+    return {
+        "name": f"call_{agent_name}",
+        "description": description,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "task": {
+                    "type": "string",
+                    "description": "Descripción detallada de la tarea a delegar al sub-agente.",
+                }
+            },
+            "required": ["task"],
+        },
+    }
+
+
+class SubAgentRunner:
+    """
+    Encapsula un sub-agente listo para ser llamado como handler de herramienta.
+    """
+
+    def __init__(
+        self,
+        agent_name: str,
+        system_prompt: str,
+        tools: list[dict] | None = None,
+        tool_handlers: dict[str, Callable] | None = None,
+        model: str = MODEL_SMART,
+    ):
+        self.agent_name = agent_name
+        self.system_prompt = system_prompt
+        self.tools = tools or []
+        self.tool_handlers = tool_handlers or {}
+        self.model = model
+
+    def as_handler(self) -> Callable[[str], str]:
+        """
+        Devuelve una función que puede usarse como handler en tool_handlers del agente padre.
+        """
+        def handler(task: str) -> str:
+            logger.info(f"[SubAgentRunner] llamando a '{self.agent_name}' con tarea: {task[:80]}...")
+            response, _ = run_agent(
+                system_prompt=self.system_prompt,
+                user_message=task,
+                tools=self.tools,
+                tool_handlers=self.tool_handlers,
+                model=self.model,
+            )
+            return response
+
+        handler.__name__ = f"call_{self.agent_name}"
+        return handler