# ROADMAP SKEEN Derma Experts: WACRM + Hermes + Odoo

## Arquitectura Tecnica Actualizada | Reemplazo Twilio → WACRM | FastAPI → Hermes

**Consultoria Alcaraz Salazar, S.A.S.**
**5 de julio de 2026**

---

## Tabla de Contenidos

1. Comparativa: Arquitectura Original vs Nueva
2. Arquitectura Detallada con WACRM + Hermes
3. Stack Tecnologico Actualizado
4. Estructura de Proyecto Actualizada
5. Skills de Hermes para SKEEN
6. Integraciones Detalladas
7. Configuracion de WACRM
8. Configuracion de Hermes
9. Roadmap Actualizado por Fase
10. Ventajas y Desventajas de esta Arquitectura
11. Requisitos del Cliente (Actualizados)
12. Presupuesto de Infraestructura Actualizado

---

## 1. Comparativa: Arquitectura Original vs Nueva

### 1.1 Tabla Comparativa General

| Componente | Arquitectura ORIGINAL | Arquitectura NUEVA (WACRM + Hermes) | Justificacion |
|------------|----------------------|-------------------------------------|---------------|
| WhatsApp Gateway | Twilio API ($0.005/msg) + webhook custom | WACRM + Meta WhatsApp Cloud API directo | Sin intermediario, inbox nativo, costo solo Meta fees (~$0.003-0.008/msg) |
| Inbox / CRM | Inbox custom en React (a construir) | WACRM shared inbox (listo) | Inbox multi-agente con asignacion, notas internas, Kanban pipelines, broadcast — sin desarrollo |
| Backend IA | FastAPI custom + GPT-4o directo | Hermes gateway + skills (SKILL.md) | Agente autonomo con 25+ tools, memoria persistente SQLite, cron nativo, multi-model, subagentes |
| Agente "Sofia" | API endpoint REST stateless | Agente autonomo Hermes con contexto | Memoria persistente, proactive (cron), skills modulares, handoff a humano, context compression |
| Pipelines de ventas | A construir en Odoo/Odoo + custom | WACRM Kanban pipelines nativos | Drag-drop, deals vinculados a conversaciones, win-rate analytics |
| Base de datos CRM | PostgreSQL custom | Supabase (PostgreSQL + RLS + Auth) | Auth built-in, Row-Level Security, Realtime subscriptions, Storage |
| Automatizaciones | Codigo custom en FastAPI | WACRM no-code automations + Hermes skills | Visual builder (Figma-like) + agente IA con razonamiento |
| Broadcasts | Twilio API custom | WACRM broadcasts con templates Meta | Templates aprobados por Meta, delivery tracking, segmentacion |
| Contactos / Leads | Tabla custom en PostgreSQL | WACRM contacts + tags + custom fields | Deduplicacion automatica, CSV import, tags, campos custom |
| AI Assistant | GPT-4o directo via API | WACRM AI Assistant (BYOK) + Hermes skills | Draft replies, auto-reply bot, knowledge base, handoff a humano |
| Costo mensual infra | ~$150-250 USD/mes | ~$80-150 USD/mes | WACRM es MIT (gratis), Hermes es MIT (gratis), solo hosting + API fees |
| Tiempo de desarrollo inbox | ~2 semanas | ~0 dias (listo) | WACRM inbox funcional dia 1 post-configuracion |
| Tiempo de desarrollo agente IA | ~3 semanas | ~1 semana (skills + config) | Hermes ya tiene tools, memoria, gateway, cron — solo configurar skills |

### 1.2 Diferencias Clave por Dimension

| Dimension | Original | Nueva | Impacto |
|-----------|----------|-------|---------|
| Complejidad de codigo | Alto (inbox + agente + CRM desde cero) | Medio (solo skills + integraciones) | ~60% menos codigo custom |
| Mantenimiento | Equipo propio mantiene todo | Comunidad open-source mantiene WACRM/Hermes | Menos deuda tecnica |
| Escalabilidad | Manual | WACRM escala con Supabase; Hermes con gateway | Mejor arquitectura cloud-native |
| Vendor lock-in | Twilio (API propietaria) | Meta Cloud API (estandar) + MIT code | Codigo propio, migrable |
| Onboarding de agentes | Desarrollo custom | WACRM invita por link, roles nativos | Minutos vs dias |
| Analytics | A construir | WACRM dashboard real-time nativo | Disponible dia 1 |
| Subagentes | No disponible | Sí — delegacion aislada con terminal propio | Tareas paralelas sin costo de contexto |
| Fallback providers | No disponible | Sí — cadena de failover automatico | Mayor resiliencia |
| Context compression | No disponible | Sí nativo — hasta 50% de ventana | Manejo de conversaciones largas |
| Credential pools | No disponible | Sí — rotacion de API keys | Mayor tolerancia a rate limits |

### 1.3 Mapa de Reemplazo de Componentes

```
Twilio API ──────────────→ Meta WhatsApp Cloud API (via WACRM)
Twilio webhooks ─────────→ WACRM webhooks (/api/v1/webhooks)
Inbox React custom ──────→ WACRM shared inbox (Next.js 16 App Router)
FastAPI backend ─────────→ Hermes gateway (Python daemon)
GPT-4o directo ──────────→ Hermes agent runtime (multi-model + fallback)
PostgreSQL CRM ──────────→ Supabase PostgreSQL + RLS
Automatizaciones code ───→ WACRM no-code automations + Hermes skills + cron
Dashboard analytics ─────→ WACRM dashboard real-time
Contact management ──────→ WACRM contacts + tags + pipelines
OpenClaw gateway ────────→ Hermes gateway (Python, mas plataformas nativas)
OpenClaw heartbeat ───────→ Hermes cron nativo (mas flexible)
OpenClaw skills ─────────→ Hermes skills (compatible agentskills.io)
OpenClaw memory MD ──────→ Hermes SQLite + MEMORY.md + plugins
```

---

## 2. Arquitectura Detallada con WACRM + Hermes

### 2.1 Diagrama de Componentes Completo

```
┌─────────────────────────────────────────────────────────────────────────────┐
│                              LAYER: PACIENTE                                │
│  WhatsApp Business (telefono SKEEN) ─── App movil del paciente              │
└─────────────────────────────────────────────────────────────────────────────┘
                                       │
                                       ▼ Meta Cloud API (HTTPS webhook)
┌─────────────────────────────────────────────────────────────────────────────┐
│                           LAYER: WACRM (CRM)                                │
│  ┌─────────────────────────────────────────────────────────────────────┐    │
│  │  WACRM — Next.js 16 + Supabase PostgreSQL                           │    │
│  │  Puerto: 3000 (interno) / HTTPS via Nginx                           │    │
│  │                                                                     │    │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────────┐  │    │
│  │  │ Shared Inbox │  │   Contacts   │  │   Sales Pipelines (Kanban)│  │    │
│  │  │ Multi-agente │  │ + Tags +     │  │   Deals → Conversaciones  │  │    │
│  │  │ Asignacion   │  │ Custom Fields│  │   Win-rate analytics      │  │    │
│  │  └──────────────┘  └──────────────┘  └──────────────────────────┘  │    │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────────┐  │    │
│  │  │  Broadcasts  │  │ Automations  │  │   AI Assistant (BYOK)    │  │    │
│  │  │  Templates   │  │   No-code    │  │  OpenAI/Anthropic key    │  │    │
│  │  │  Meta        │  │   Triggers   │  │  Auto-reply + Handoff    │  │    │
│  │  └──────────────┘  └──────────────┘  └──────────────────────────┘  │    │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────────┐  │    │
│  │  │   Dashboard  │  │    Flows     │  │   Templates Manager      │  │    │
│  │  │  Real-time   │  │  Chatbots    │  │   Meta approval sync     │  │    │
│  │  └──────────────┘  └──────────────┘  └──────────────────────────┘  │    │
│  └─────────────────────────────────────────────────────────────────────┘    │
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────┐    │
│  │  API REST PUBLICA: /api/v1                                          │    │
│  │  ├── POST   /messages          (enviar WhatsApp)                    │    │
│  │  ├── GET    /contacts          (listar contactos)                   │    │
│  │  ├── POST   /contacts          (crear/find-or-create)               │    │
│  │  ├── GET    /conversations     (listar conversaciones)              │    │
│  │  ├── GET    /conversations/:id/messages (thread)                    │    │
│  │  ├── POST   /broadcasts        (campaña broadcast)                  │    │
│  │  ├── POST   /webhooks          (registrar webhook outbound)         │    │
│  │  └── GET    /me                (info cuenta + scopes)               │    │
│  │                                                                     │    │
│  │  Webhooks outbound (a Hermes):                                     │    │
│  │  ├── message.received          (nuevo mensaje)                      │    │
│  │  ├── message.status_updated    (delivery/read)                      │    │
│  │  └── conversation.created      (nueva conversacion)                │    │
│  └─────────────────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────────────────┘
                                       │
                    ┌──────────────────┼──────────────────┐
                    │                  │                  │
                    ▼                  ▼                  ▼
┌───────────────────────┐   ┌─────────────────┐   ┌──────────────────────────┐
│  LAYER: Hermes        │   │ LAYER: Odoo 17  │   │  LAYER: Frontend React   │
│  (Agente IA "Sofia")  │   │  (Backend ERP)  │   │  (app.skeen.mx)          │
│                       │   │                 │   │                          │
│  Gateway Python       │   │  Modulos:       │   │  Dashboard clinicos      │
│  Puerto: 8080 (HTTP)  │   │  ├── Pacientes  │   │  Agenda citas            │
│  + WS API (cron)      │   │  ├── Citas      │   │  Monedero digital        │
│  Daemon (systemd)     │   │  ├── Historial  │   │  Pagos (Stripe/MP)       │
│                       │   │  ├── Inventario │   │  Reportes                │
│  ┌──────────────────┐ │   │  ├── POS        │   │                          │
│  │  Agent Runtime   │ │   │  ├── Monedero   │   │  Auth: Odoo JWT          │
│  │  ├─ SOUL.md      │ │   │  └── Website    │   │  API: Odoo REST +        │
│  │  ├─ AGENTS.md    │ │   │                 │   │       WACRM REST         │
│  │  ├─ SKILL.md (5) │ │   │  API REST XML/   │   │                          │
│  │  ├─ MEMORY.md    │ │   │  JSON (custom)   │   │  Puerto: 5173 (dev)      │
│  │  └─ SQLite state │ │   │                 │   │         80/443 (prod)    │
│  └──────────────────┘ │   └─────────────────┘   └──────────────────────────┘
│                       │
│  ┌──────────────────┐ │
│  │  Cron (nativo)   │ │
│  │  ├─ Recordatorios│ │
│  │  ├─ Follow-ups   │ │
│  │  └─ Re-engagement│ │
│  └──────────────────┘ │
│                       │
│  ┌──────────────────┐ │
│  │  Tools Built-in  │ │
│  │  ├─ web_search   │ │
│  │  ├─ web_fetch    │ │
│  │  ├─ exec (python)│ │
│  │  ├─ shell        │ │
│  │  ├─ browser      │ │
│  │  └─ file R/W     │ │
│  └──────────────────┘ │
│                       │
│  ┌──────────────────┐ │
│  │  Custom Plugins  │ │
│  │  ├─ odoo_api_call│ │
│  │  ├─ wacrm_send   │ │
│  │  └─ calendar_check│ │
│  └──────────────────┘ │
│                       │
│  ┌──────────────────┐ │
│  │  API Server      │ │
│  │  /v1/chat/completions│ │
│  │  /api/jobs (cron)│ │
│  └──────────────────┘ │
└───────────────────────┘
```

### 2.2 Flujo de Datos Paso a Paso

#### FLUJO 1: Primera vez que un paciente escribe por WhatsApp

```
[1] Paciente envia "Hola, quiero agendar una cita" por WhatsApp
         │
         ▼
[2] Meta WhatsApp Cloud API recibe el mensaje
         │
         ▼
[3] Meta envia webhook HTTPS a WACRM: POST /api/whatsapp/webhook
         │
         ▼
[4] WACRM procesa:
     - Crea/actualiza contacto (telefono, nombre si disponible)
     - Crea conversacion en inbox
     - Almacena mensaje en Supabase
     - Dispara trigger de automatizacion ("Nuevo mensaje")
         │
         ├──► WACRM AI Assistant (opcional, si auto-reply activo)
         │
         └──► Webhook outbound a Hermes: POST http://hermes:8080/webhook/wacrm
                  │
                  ▼
[5] Hermes Gateway recibe webhook via HTTP endpoint custom
     - Parsea payload: { event: "message.received", data: { from, text, conversation_id } }
     - Inicia/continua sesion para ese contacto (SQLite session store)
     - Inyecta skills relevantes al contexto
         │
         ▼
[6] Hermes Agent Runtime procesa con LLM (GPT-4o):
     - Lee skills: skeen-rag.md (catalogo) + skeen-agendar.md (citas)
     - Detecta intencion: "agendar_cita"
     - Consulta disponibilidad via plugin odoo_api_call
         │
         ▼
[7] Hermes → Odoo API (XML-RPC/JSON-RPC):
     - Consulta slots disponibles del dermatologo
     - Recibe: ["2026-07-05 10:00", "2026-07-05 14:00", "2026-07-06 09:00"]
         │
         ▼
[8] Hermes formatea respuesta y envia a WACRM:
     POST /api/v1/messages
     { "to": "+526641234567", "type": "text",
       "text": "Hola! Soy Sofia de SKEEN. Puedo agendarte para:
               1. Sab 5 jul 10:00 AM
               2. Sab 5 jul 2:00 PM
               3. Dom 6 jul 9:00 AM
               Cual prefieres?" }
         │
         ▼
[9] WACRM envia via Meta Cloud API → WhatsApp → Paciente
         │
         ▼
[10] Respuesta del paciente: "El sabado a las 10"
          │
          └──► Repite [2]→[6], Hermes confirma cita
               └──► Odoo: crea cita + WACRM: envia confirmacion
```

#### FLUJO 2: Confirmacion de cita + Recordatorio automatico

```
[1] Hermes crea la cita en Odoo via odoo_api_call
     - Modelo: salon.booking (o calendar.event)
     - Datos: paciente_id, servicio_id, fecha_hora, estado='confirmada'
         │
         ▼
[2] Hermes programa recordatorio via cron nativo:
     - hermes cron schedule --name "recordatorio-cita-[ID]" \
       --at "2026-07-04 18:00" \
       --command "skill skeen-recordatorios --phone +526641234567 --cita 2026-07-05T10:00"
         │
         ▼
[3] Cron de Hermes ejecuta a la hora programada:
     - Skill skeen-recordatorios se activa
     - Consulta Odoo: citas para manana (5 jul)
     - Para cada cita sin recordatorio enviado:
       └──► WACRM API: POST /api/v1/messages
            { "to": "+526641234567", "type": "template",
              "template": { "name": "recordatorio_cita_skeen",
                            "language": "es_MX",
                            "params": ["Sofia", "5 de julio", "10:00 AM"] } }
         │
         ▼
[4] WACRM envia template aprobado por Meta → WhatsApp → Paciente
     "Hola Sofia! Te recordamos tu cita manana 5 de julio a las 10:00 AM
      en SKEEN Derma Experts. Ubicacion: Blvd. Popotla 123, Rosarito."
         │
         ▼
[5] Odoo marca recordatorio como enviado
```

#### FLUJO 3: Pago de cita + Monedero digital

```
[1] Paciente despues de cita: "Quiero pagar mi tratamiento"
         │
         ▼
[2] WACRM → Hermes (webhook message.received)
         │
         ▼
[3] Hermes skill skeen-pagos.md:
     - Consulta Odoo: citas del paciente + servicios pendientes de pago
     - Calcula total
     - Genera link de pago (Stripe Checkout / MercadoPago preference)
         │
         ▼
[4] Hermes responde via WACRM:
     "Tu tratamiento de Acne Control tiene un saldo de $1,200 MXN.
      Puedes pagar aqui: [Link Stripe] o [Link MercadoPago]
      Tambien acumulas 120 puntos en tu monedero SKEEN!"
         │
         ▼
[5] Paciente paga via Stripe/MP
         │
         ▼
[6] Webhook Stripe/MP → Odoo (confirmacion de pago)
     - Odoo actualiza estado de factura
     - Odoo acumula puntos en monedero del paciente
         │
         ▼
[7] Hermes cron detecta pago confirmado:
     - WACRM: envia confirmacion + saldo de monedero
     "Pago confirmado! Gracias Sofia. Tu monedero SKEEN: 450 puntos
      (equivalente a $450 MXN). Los puedes usar en tu proxima visita."
```

### 2.3 Diagrama de Secuencia: Agendar Cita Completa

```
Paciente          WhatsApp         Meta API        WACRM          Hermes        Odoo
   │                  │                │              │               │             │
   │ "Hola, quiero    │                │              │               │             │
   │  agendar"        │                │              │               │             │
   │─────────────────>│                │              │               │             │
   │                  │                │              │               │             │
   │                  │  Webhook msg   │              │               │             │
   │                  │<───────────────│              │               │             │
   │                  │                │              │               │             │
   │                  │                │  POST /webhook              │             │
   │                  │                │─────────────>│               │             │
   │                  │                │              │  message.received             │
   │                  │                │              │  webhook outbound             │
   │                  │                │              │──────────────>│             │
   │                  │                │              │               │             │
   │                  │                │              │               │ odoo_api_call│
   │                  │                │              │               │ (slots libres)│
   │                  │                │              │               │─────────────>│
   │                  │                │              │               │             │
   │                  │                │              │               │<─────────────│
   │                  │                │              │               │  ["10:00",   │
   │                  │                │              │               │   "14:00"]   │
   │                  │                │              │               │             │
   │                  │                │  POST /api/v1/messages       │             │
   │                  │                │<─────────────│               │             │
   │                  │                │  (WACRM envia opciones)      │             │
   │                  │                │              │               │             │
   │                  │  Template msg  │              │               │             │
   │                  │<───────────────│              │               │             │
   │  "Hola! Opciones:│                │              │               │             │
   │   1. 10:00..."  │                │              │               │             │
   │<─────────────────│                │              │               │             │
   │                  │                │              │               │             │
   │ "Opcion 1"       │                │              │               │             │
   │─────────────────>│                │              │               │             │
   │                  │ ... (mismo flujo) ...          │               │             │
   │                  │                │              │               │             │
   │                  │                │              │               │ odoo_api_call│
   │                  │                │              │               │ (crear cita) │
   │                  │                │              │               │─────────────>│
   │                  │                │              │               │             │
   │                  │                │  POST /api/v1/messages       │             │
   │                  │                │<─────────────│               │             │
   │                  │                │              │               │             │
   │  "Cita confirmada│                │              │               │             │
   │   para 5 jul 10AM│               │              │               │             │
   │   con Dra. Ana"  │                │              │               │             │
   │<─────────────────│                │              │               │             │
   │                  │                │              │               │             │
```

### 2.4 Comunicacion entre Componentes

| De | A | Protocolo | Auth | Payload |
|----|---|-----------|------|---------|
| Meta API | WACRM | HTTPS webhook | Verify Token HMAC | JSON mensaje |
| WACRM | Meta API | HTTPS REST | Bearer Access Token | JSON mensaje/template |
| WACRM | Hermes | HTTPS webhook outbound | HMAC-SHA256 signature | JSON evento |
| Hermes | WACRM | HTTPS REST | Bearer API Key (wacrm_live_*) | JSON mensaje |
| Hermes | Odoo | XML-RPC / JSON-RPC / HTTP | API Key / OAuth | XML/JSON |
| Odoo | Frontend | HTTPS REST (CORS) | JWT Token | JSON |
| Frontend | WACRM | HTTPS REST | Bearer API Key | JSON (dashboard unificado) |
| Hermes | LLM Provider | HTTPS SSE/REST | Bearer API Key | JSON (OpenAI/Anthropic format) |
| Hermes | Hermes API | HTTPS REST | Bearer Token | JSON (OpenAI-compatible) |

---

## 3. Stack Tecnologico Actualizado

### 3.1 Tabla Completa de Tecnologias

#### WACRM (CRM WhatsApp)

| Capa | Tecnologia | Version | Proposito | Licencia/Costo |
|------|-----------|---------|-----------|---------------|
| Framework | Next.js | 16 (App Router) | SSR + API routes + ISR | MIT / Gratis |
| UI | React | 19 | Componentes interactivos | MIT / Gratis |
| Lenguaje | TypeScript | 5.x | Tipado estatico | OSS / Gratis |
| Estilos | Tailwind CSS | v4 | Utility-first CSS | MIT / Gratis |
| UI Kit | shadcn/ui + base-ui | latest | Componentes accesibles | MIT / Gratis |
| Database | Supabase (PostgreSQL) | 15+ | Datos + Auth + RLS + Realtime | OSS Cloud / ~$25/mes |
| Auth | Supabase Auth | built-in | Email/password + JWT | Incluido |
| Storage | Supabase Storage | built-in | Avatares + media | Incluido |
| WhatsApp | Meta Cloud API | v18.0+ | Mensajeria oficial | Meta fees |
| Encriptacion | node:crypto | built-in | AES-256-GCM tokens | built-in |

#### Hermes (Agente IA)

| Capa | Tecnologia | Version | Proposito | Licencia/Costo |
|------|-----------|---------|-----------|---------------|
| Runtime | Python | 3.11+ | Gateway daemon | OSS / Gratis |
| Package | uv / pip | latest | Gestor de paquetes | OSS / Gratis |
| Gateway | hermes-agent | 0.14.0+ | Gateway HTTP + WS + API | MIT / Gratis |
| Comunicacion | HTTP / WebSocket | RFC 6455 | Gateway ↔ clients | built-in |
| Skills | SKILL.md (Markdown) | agentskills.io | Capacidades del agente | MIT / Gratis |
| Memory | SQLite + MEMORY.md | - | Memoria persistente + FTS5 search | File system |
| Cron | hermes cron | built-in | Tareas programadas | built-in |
| LLM Provider | OpenAI GPT-4o | latest | Modelo principal | ~$0.005-0.015/token |
| Fallback LLM | Claude 3.5 Sonnet | latest | Fallback / tareas complejas | ~$0.003-0.015/token |
| Fallback chain | Hermes nativo | 0.6.0+ | Failover automatico | built-in |
| Local LLM | Ollama / LM Studio | 0.4+ / 0.12.0+ | Desarrollo offline | OSS / Gratis |
| Context compression | Hermes nativo | built-in | Compresion de contexto | built-in |
| Credential pools | Hermes nativo | 0.7.0+ | Rotacion de API keys | built-in |
| Subagentes | Hermes delegate | built-in | Tareas aisladas | built-in |
| API Server | OpenAI-compatible | 0.4.0+ | /v1/chat/completions | built-in |
| TUI | Ink (React) | 0.11.0+ | Interfaz terminal interactiva | built-in |
| Plugins | Python files | 0.3.0+ | Custom tools | built-in |
| MCP | Model Context Protocol | 0.4.0+ | Integracion MCP | built-in |

#### Odoo 17 (ERP)

| Capa | Tecnologia | Version | Proposito | Licencia/Costo |
|------|-----------|---------|-----------|---------------|
| ERP | Odoo Community | 17.0 | Backend negocio completo | LGPL / Gratis |
| Lenguaje | Python | 3.10+ | Logica de servidor | OSS |
| Database | PostgreSQL | 15+ | Datos ERP (compartido con Supabase o separado) | OSS |
| Cache | Redis | 7.x | Cache + sessions + queue | BSD / Gratis |
| Queue | Celery + Redis | 5.x+ | Tareas asincronas | OSS |

#### Frontend SKEEN

| Capa | Tecnologia | Version | Proposito | Licencia/Costo |
|------|-----------|---------|-----------|---------------|
| Framework | React | 18 | UI components | MIT / Gratis |
| Lenguaje | TypeScript | 5.x | Tipado estatico | OSS |
| Build | Vite | 5.x+ | Bundler + dev server | MIT / Gratis |
| Estilos | Tailwind CSS | v3+ | Estilos utility-first | MIT / Gratis |
| Routing | React Router | v6+ | SPA routing | MIT / Gratis |
| HTTP Client | Axios | 1.6+ | Llamadas API | MIT / Gratis |
| Estado | Zustand | 4.x+ | State management | MIT / Gratis |
| Calendario | react-big-calendar | 1.x+ | Vista agenda citas | MIT |
| Charts | Recharts | 2.x+ | Graficos dashboard | MIT |

#### Infraestructura

| Capa | Tecnologia | Version | Proposito | Licencia/Costo |
|------|-----------|---------|-----------|---------------|
| VPS | Hetzner Cloud | CPX31 | 4 vCPU / 8 GB / 160 GB SSD | ~$15/mes |
| OS | Ubuntu Server | 24.04 LTS | Sistema operativo | Gratis |
| Proxy | Nginx | 1.24+ | Reverse proxy + SSL + rate limit | BSD |
| SSL | Let's Encrypt | latest | Certificados HTTPS gratis | Gratis |
| Contenedores | Docker | 25.x+ | Container runtime | Apache 2.0 |
| Orquestacion | Docker Compose | 2.24+ | Multi-container local | Apache 2.0 |
| DNS | Cloudflare | Free tier | DNS + CDN + DDoS protection | Gratis |
| Monitoreo | Uptime Kuma | 1.x+ | Health checks + alerting | MIT |

#### Pagos

| Capa | Tecnologia | Version | Proposito | Costo |
|------|-----------|---------|-----------|-------|
| Pagos intl | Stripe | latest | Tarjetas internacionales | 2.9% + $0.30 |
| Pagos MX | MercadoPago | latest | OXXO, tarjetas MX, SPEI | 3.5-4.5% |

#### Desarrollo

| Capa | Tecnologia | Version | Proposito | Licencia/Costo |
|------|-----------|---------|-----------|---------------|
| Git | GitHub | - | Repositorios + CI/CD | Free/Pro |
| IDE | VS Code | latest | Editor + extensions | Gratis |
| API Testing | Postman / Hoppscotch | latest | Test APIs | Gratis |
| DB Admin | pgAdmin / Tableplus | latest | Admin PostgreSQL | Gratis |

### 3.2 Diagrama de Puertos y Servicios

| Servicio | Puerto Interno | Puerto Externo | Path Nginx |
|----------|---------------|----------------|------------|
| WACRM (Next.js) | 3000 | 443 | /crm/* → localhost:3000 |
| Hermes Gateway | 8080 | 443 | /webhook/* → localhost:8080 |
| Hermes API Server | 8080 (mismo) | - | Solo interno (localhost) |
| Hermes TUI | - | - | Interactivo local |
| Odoo | 8069 | 443 | /odoo/* → localhost:8069 |
| Odoo Longpolling | 8072 | - | Solo interno |
| Frontend React | 5173 (dev) / 80 (prod) | 443 | / → localhost:80 |
| PostgreSQL | 5432 | - | Solo interno |
| Redis | 6379 | - | Solo interno |
| Nginx | 80, 443 | 80, 443 | Reverse proxy principal |
| Uptime Kuma | 3001 | 443 | /status → localhost:3001 |

---

## 4. Estructura de Proyecto Actualizada

### 4.1 Repositorios Git

```
skeen-derma-experts/                          (organizacion GitHub)
├── wacrm/                                    (fork de ArnasDon/wacrm)
│   ├── src/
│   │   ├── app/
│   │   │   ├── (auth)/                       # login, signup
│   │   │   ├── (dashboard)/                  # UI autenticada
│   │   │   │   ├── dashboard/                # home / metrics
│   │   │   │   ├── inbox/                    # shared inbox
│   │   │   │   ├── contacts/                 # contactos + tags
│   │   │   │   ├── pipelines/                # Kanban deals
│   │   │   │   ├── broadcasts/               # campañas
│   │   │   │   ├── automations/              # flow builder
│   │   │   │   └── settings/                 # perfil / WhatsApp / API keys
│   │   │   ├── api/                          # endpoints server-only
│   │   │   │   ├── whatsapp/webhook/         # inbound desde Meta
│   │   │   │   ├── whatsapp/send/            # outbound a Meta
│   │   │   │   ├── automations/              # engine + cron
│   │   │   │   └── v1/                       # API publica (messages, contacts, etc.)
│   │   ├── components/
│   │   ├── lib/
│   │   │   ├── supabase/                     # client, server, middleware
│   │   │   ├── whatsapp/                     # Meta API client
│   │   │   └── automations/                  # engine, steps, validation
│   │   └── types/
│   ├── supabase/migrations/                  # SQL idempotente
│   ├── .env.local                            # variables de entorno
│   └── package.json
│
├── hermes/                                   # Gateway + Skills SKEEN
│   ├── .hermes/
│   │   ├── config.yaml                       # config principal
│   │   ├── plugins/
│   │   │   ├── odoo_api_call.py              # plugin Odoo XML-RPC
│   │   │   ├── wacrm_send.py                 # plugin WACRM API
│   │   │   └── calendar_check.py             # plugin disponibilidad
│   │   └── workspace/
│   │       ├── AGENTS.md                     # instrucciones operativas
│   │       ├── SOUL.md                       # personalidad "Sofia"
│   │       ├── MEMORY.md                     # memoria persistente
│   │       ├── TOOLS.md                      # notas de tools
│   │       ├── IDENTITY.md                   # nombre/vibe/emoji
│   │       └── USER.md                       # perfil clinica
│   ├── skills/
│   │   ├── skeen-rag/
│   │   │   └── SKILL.md                      # catalogo servicios
│   │   ├── skeen-agendar/
│   │   │   └── SKILL.md                      # agendamiento citas
│   │   ├── skeen-pagos/
│   │   │   └── SKILL.md                      # pagos Stripe/MP
│   │   ├── skeen-monedero/
│   │   │   └── SKILL.md                      # monedero digital
│   │   └── skeen-recordatorios/
│   │       └── SKILL.md                      # recordatorios citas
│   ├── webhooks/
│   │   └── wacrm_webhook_server.py           # servidor HTTP para webhooks WACRM
│   ├── pyproject.toml
│   ├── requirements.txt
│   └── Dockerfile
│
├── odoo-backend/                             # Odoo 17 + modulos custom
│   ├── odoo/
│   │   ├── addons/
│   │   │   ├── skeen_pacientes/              # gestion pacientes
│   │   │   ├── skeen_citas/                  # agendamiento
│   │   │   ├── skeen_monedero/               # monedero digital
│   │   │   ├── skeen_pagos/                  # integracion Stripe/MP
│   │   │   ├── skeen_whatsapp/               # webhook WACRM → Odoo
│   │   │   └── skeen_reportes/               # reportes clinicos
│   │   └── odoo.conf
│   ├── Dockerfile
│   └── docker-compose.yml
│
├── frontend/                                 # React 18 + TypeScript
│   ├── src/
│   │   ├── components/                       # UI components
│   │   ├── pages/                            # vistas (Home, Agenda, Pagos)
│   │   ├── hooks/                            # custom hooks
│   │   ├── services/                         # API clients (Odoo + WACRM)
│   │   ├── store/                            # Zustand state
│   │   └── types/                            # TypeScript types
│   ├── package.json
│   └── Dockerfile
│
└── infra/                                    # Docker Compose completo
    ├── docker-compose.yml                    # orquestacion total
    ├── .env                                  # variables globales
    ├── nginx/
    │   ├── nginx.conf                        # reverse proxy
    │   └── ssl/                              # certificados Let's Encrypt
    ├── scripts/
    │   ├── init-supabase.sh                  # migraciones SQL
    │   ├── setup-wacrm.sh                    # post-install WACRM
    │   └── setup-hermes.sh                   # post-install Hermes
    └── monitoring/
        ├── uptime-kuma/                      # health checks
        └── prometheus/                       # metrics (opcional)
```

### 4.2 Estructura de Docker Compose

```yaml
# infra/docker-compose.yml — Resumen de servicios

services:
  # ── WACRM (CRM WhatsApp) ──────────────────────────────
  wacrm:
    build: ../wacrm/
    ports: ["3000:3000"]
    environment:
      - NEXT_PUBLIC_SUPABASE_URL=${SUPABASE_URL}
      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${SUPABASE_ANON_KEY}
      - SUPABASE_SERVICE_ROLE_KEY=${SUPABASE_SERVICE_ROLE}
      - ENCRYPTION_KEY=${WACRM_ENCRYPTION_KEY}
      - WHATSAPP_PHONE_NUMBER_ID=${META_PHONE_ID}
      - WHATSAPP_BUSINESS_ACCOUNT_ID=${META_BUSINESS_ID}
      - WHATSAPP_ACCESS_TOKEN=${META_ACCESS_TOKEN}
      - WHATSAPP_VERIFY_TOKEN=${META_VERIFY_TOKEN}
    depends_on: [postgres, redis]

  # ── Hermes (Agente IA) ──────────────────────────────
  hermes:
    build: ../hermes/
    ports: ["8080:8080"]
    environment:
      - HERMES_MODEL_PROVIDER=openai
      - HERMES_MODEL=gpt-4o
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - ODOO_URL=http://odoo:8069
      - ODOO_DB=skeen
      - ODOO_API_KEY=${ODOO_API_KEY}
      - WACRM_URL=http://wacrm:3000
      - WACRM_API_KEY=${WACRM_API_KEY}
      - HERMES_WEBHOOK_PORT=8080
      - HERMES_API_SERVER_ENABLED=true
      - HERMES_CRON_ENABLED=true
    volumes:
      - hermes_workspace:/root/.hermes/workspace
      - hermes_plugins:/root/.hermes/plugins
      - ./../hermes/skills:/skills:ro
    depends_on: [odoo, wacrm]
    command: ["hermes", "gateway", "start"]

  # ── Odoo 17 (ERP) ─────────────────────────────────────
  odoo:
    build: ../odoo-backend/
    ports: ["8069:8069", "8072:8072"]
    environment:
      - HOST=postgres
      - PORT=5432
      - USER=odoo
      - PASSWORD=${POSTGRES_PASSWORD}
      - DB_NAME=skeen
    volumes:
      - odoo_data:/var/lib/odoo
      - ./../odoo-backend/odoo/addons:/mnt/extra-addons:ro
    depends_on: [postgres, redis]

  # ── Frontend React ────────────────────────────────────
  frontend:
    build: ../frontend/
    ports: ["80:80"]
    depends_on: [odoo, wacrm]

  # ── PostgreSQL ────────────────────────────────────────
  postgres:
    image: postgres:15-alpine
    ports: ["5432:5432"]
    environment:
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=skeen
    volumes:
      - postgres_data:/var/lib/postgresql/data

  # ── Redis ─────────────────────────────────────────────
  redis:
    image: redis:7-alpine
    ports: ["6379:6379"]
    volumes:
      - redis_data:/data

  # ── Nginx (Reverse Proxy) ─────────────────────────────
  nginx:
    image: nginx:1.24-alpine
    ports: ["443:443"]
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on: [wacrm, odoo, frontend, hermes]

  # ── Uptime Kuma ───────────────────────────────────────
  uptime-kuma:
    image: louislam/uptime-kuma:1
    ports: ["3001:3001"]
    volumes:
      - uptime_data:/app/data

volumes:
  hermes_workspace:
  hermes_plugins:
  odoo_data:
  postgres_data:
  redis_data:
  uptime_data:
```

### 4.3 Variables de Entorno (.env)

```bash
# ============================================================
# INFRA — infra/.env
# ============================================================

# PostgreSQL
POSTGRES_PASSWORD=skeen_postgres_2026_secure
POSTGRES_USER=odoo
POSTGRES_DB=skeen

# Redis
REDIS_PASSWORD=skeen_redis_2026

# WACRM
SUPABASE_URL=http://postgres:5432
SUPABASE_ANON_KEY=eyJ...
SUPABASE_SERVICE_ROLE=eyJ...
WACRM_ENCRYPTION_KEY=a1b2c3d4e5f6... # 64 chars hex AES-256
META_PHONE_ID=123456789012345
META_BUSINESS_ID=987654321098765
META_ACCESS_TOKEN=EAA...
META_VERIFY_TOKEN=skeen_webhook_verify_2026

# Hermes
OPENAI_API_KEY=sk-proj-...
ANTHROPIC_API_KEY=sk-ant-...
HERMES_MODEL_PROVIDER=openai
HERMES_MODEL=gpt-4o
HERMES_FALLBACK_PROVIDERS=anthropic,openrouter
HERMES_API_SERVER_ENABLED=true
HERMES_CRON_ENABLED=true
HERMES_WEBHOOK_PORT=8080
HERMES_TUI_ENABLED=false
ODOO_API_KEY=skeen_odoo_api_key_2026
WACRM_API_KEY=wacrm_live_xxxxxxxx

# Stripe / MercadoPago
STRIPE_SECRET_KEY=sk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...
MP_ACCESS_TOKEN=TEST-...
MP_PUBLIC_KEY=TEST-...

# Dominio
DOMAIN=skeen.mx
WACRM_SUBDOMAIN=crm.skeen.mx
ODOO_SUBDOMAIN=erp.skeen.mx
APP_SUBDOMAIN=app.skeen.mx
HERMES_SUBDOMAIN=hermes.skeen.mx
```

## 5. Skills de Hermes para SKEEN

### 5.1 Overview de Skills

En Hermes, una skill es una carpeta con un archivo `SKILL.md` que define una capacidad del agente. El archivo contiene:
- **YAML frontmatter:** metadata (nombre, descripcion, version, requisitos, plataformas, activacion)
- **Markdown body:** instrucciones detalladas de como ejecutar la skill

Las skills se cargan dinamicamente en el contexto del agente segun la intencion detectada. El agente puede invocar plugins (built-in o custom) para cumplir con la skill.

Hermes es compatible con el estandar [agentskills.io](https://agentskills.io) y tiene 166+ skills rastreadas (87 bundled + 79 optional). Las skills de SKEEN siguen este formato estandar.

### 5.2 Skill: skeen-rag — Catalogo de Servicios

**Que hace:** Proporciona informacion sobre los servicios dermatologicos de SKEEN (tratamientos, precios, duracion, contraindicaciones). Funciona como un sistema RAG (Retrieval-Augmented Generation) usando la memoria del agente.

**Plugins que usa:**
- `web_fetch` — si necesita consultar pagina web de SKEEN
- `memory_read` — leer catalogo almacenado en memoria
- `file_read` — leer archivo de catalogo local

**Flujo de ejecucion:**
1. Paciente pregunta: "Que tratamientos tienen para acne?"
2. Hermes detecta intencion de consulta de catalogo → carga skill `skeen-rag`
3. El agente lee el catalogo de servicios desde memoria o archivo
4. Formatea respuesta con tratamientos relevantes, precios y duracion
5. Envia respuesta via WACRM API

**Integracion:** Los servicios se sincronizan desde Odoo (`product.template`) a un archivo JSON que Hermes lee periodicamente.

**Archivo:** `skills/hermes-skeen/skeen-rag/SKILL.md`

### 5.3 Skill: skeen-agendar — Agendamiento de Citas

**Que hace:** Gestiona todo el flujo de agendamiento: consultar disponibilidad, crear citas, reagendar, cancelar, y confirmar. Se integra con Odoo para leer/escribir en el modulo de citas.

**Plugins que usa:**
- `odoo_api_call` — consultar slots disponibles, crear cita
- `wacrm_send` — enviar mensaje de confirmacion al paciente
- `memory_write` — guardar estado de la conversacion de agendamiento

**Flujo de ejecucion:**
1. Paciente: "Quiero agendar una cita"
2. Hermes carga skill `skeen-agendar`
3. Pregunta tipo de servicio (si no se especifico)
4. Consulta Odoo: `salon.booking` / `calendar.event` — slots libres
5. Presenta opciones al paciente
6. Paciente selecciona fecha/hora
7. Pide confirmacion de datos (nombre, telefono)
8. Crea cita en Odoo via `odoo_api_call`
9. Envia confirmacion via WACRM
10. Programa recordatorio via `hermes cron`

**Integracion:** El modulo `skeen_citas` de Odoo expone metodos para consultar disponibilidad y crear citas.

**Archivo:** `skills/hermes-skeen/skeen-agendar/SKILL.md`

### 5.4 Skill: skeen-pagos — Pagos Stripe + MercadoPago

**Que hace:** Gestiona el cobro de servicios, genera links de pago, consulta estado de pagos, y gestiona facturacion. Se integra con Stripe y MercadoPago via Odoo.

**Plugins que usa:**
- `odoo_api_call` — consultar servicios pendientes, registrar pago
- `wacrm_send` — enviar link de pago
- `web_fetch` — consultar estado de pago en Stripe/MP

**Archivo:** `skills/hermes-skeen/skeen-pagos/SKILL.md`

### 5.5 Skill: skeen-monedero — Monedero Digital

**Que hace:** Gestiona el monedero de puntos/fidelidad de SKEEN. Cada $10 MXN gastados = 1 punto = $1 MXN. Los pacientes pueden consultar saldo, redimir puntos, y ver historial.

**Plugins que usa:**
- `odoo_api_call` — consultar/acumular/redimir puntos
- `wacrm_send` — enviar saldo y confirmaciones

**Archivo:** `skills/hermes-skeen/skeen-monedero/SKILL.md`

### 5.6 Skill: skeen-recordatorios — Recordatorios de Citas

**Que hace:** Gestion recordatorios automaticos de citas, follow-ups post-tratamiento, y re-engagement de pacientes inactivos. Se ejecuta principalmente via `hermes cron`.

**Plugins que usa:**
- `memory_read` — leer recordatorios pendientes
- `odoo_api_call` — consultar citas proximas, pacientes inactivos
- `wacrm_send` — enviar recordatorio via WhatsApp

**Archivo:** `skills/hermes-skeen/skeen-recordatorios/SKILL.md`

### 5.7 Resumen de Skills

| Skill | Trigger Principal | Plugins | Frecuencia |
|-------|-------------------|---------|------------|
| skeen-rag | Pregunta sobre servicios | file_read, memory_read | On-demand |
| skeen-agendar | "Agendar", "cita", "hora" | odoo_api_call, wacrm_send | On-demand |
| skeen-pagos | "Pagar", "saldo", "deuda" | odoo_api_call, wacrm_send | On-demand |
| skeen-monedero | "Puntos", "monedero" | odoo_api_call, wacrm_send | On-demand |
| skeen-recordatorios | Cron (6h/18h/9AM) | odoo_api_call, wacrm_send | Programado |

---

## 6. Integraciones Detalladas

### 6.1 WACRM ↔ Odoo: Sincronizacion de Datos

**Objetivo:** Mantener contactos, conversaciones y pipelines sincronizados entre WACRM y Odoo.

**Sincronizacion de Contactos**

| Direccion | Trigger | Datos | Metodo |
|-----------|---------|-------|--------|
| WACRM → Odoo | Nuevo mensaje de numero desconocido | Telefono, nombre | Webhook: Hermes como middleware |
| Odoo → WACRM | Nuevo paciente registrado en frontend | Nombre, telefono, email, tags | WACRM API POST /api/v1/contacts |
| Bidireccional | Actualizacion de datos | Tags, custom fields | Sync cada 5 min via cron |

**Implementacion:**

```python
# hermes/plugins/sync_contacts_wacrm_odoo.py
# Ejecutar cada 5 minutos via hermes cron

import requests
from odoo_api_call import odoo_search_read, odoo_create, odoo_write

WACRM_URL = "http://wacrm:3000"
WACRM_API_KEY = "wacrm_live_xxx"


def sync_contacts():
    # 1. Obtener contactos nuevos de WACRM
    wacrm_contacts = requests.get(
        f"{WACRM_URL}/api/v1/contacts?limit=100",
        headers={"Authorization": f"Bearer {WACRM_API_KEY}"}
    ).json()

    # 2. Para cada contacto nuevo, crear/actualizar en Odoo
    for contact in wacrm_contacts.get("data", []):
        odoo_partner = odoo_search_read(
            model="res.partner",
            domain=[["phone", "=", contact["phone"]]],
            fields=["id"]
        )

        if not odoo_partner:
            odoo_create("res.partner", {
                "name": contact.get("name", "Paciente WhatsApp"),
                "phone": contact["phone"],
                "email": contact.get("email", ""),
                "is_patient": True,
                "source": "whatsapp",
                "wacrm_contact_id": contact["id"]
            })

    # 3. Sync inverso: pacientes Odoo → WACRM
    odoo_patients = odoo_search_read(
        model="res.partner",
        domain=[["is_patient", "=", True], ["wacrm_synced", "!=", True]],
        fields=["name", "phone", "email"]
    )

    for patient in odoo_patients:
        requests.post(f"{WACRM_URL}/api/v1/contacts", json={
            "phone": patient["phone"],
            "name": patient["name"],
            "email": patient.get("email"),
            "tags": ["paciente-odoo"]
        }, headers={"Authorization": f"Bearer {WACRM_API_KEY}"})
        
        odoo_write("res.partner", [patient["id"]], {"wacrm_synced": True})
```

**Sincronizacion de Pipelines**

Los pipelines de WACRM (Kanban deals) se sincronizan con el CRM de Odoo:

| WACRM Pipeline | Odoo Equivalente | Sync |
|----------------|------------------|------|
| Lead Nuevo | res.partner (stage: new) | Bidireccional via webhook |
| Consulta Programada | salon.booking (state: confirmed) | Odoo → WACRM tag |
| Tratamiento Activo | sale.order (state: sale) | Odoo → WACRM deal |
| Tratamiento Completado | account.move (paid) | Odoo → WACRM tag "completado" |
| Recurrente | res.partner (last_visit < 90d) | WACRM → Odoo campo |

### 6.2 Hermes ↔ Odoo: API REST

**Conexion:** Hermes usa el modulo custom `skeen_whatsapp` en Odoo que expone endpoints JSON-RPC/XML-RPC.

**Metodos expuestos por Odoo**

```python
# odoo-backend/odoo/addons/skeen_whatsapp/controllers/main.py

from odoo import http
from odoo.http import request
import json

class SkeenWhatsAppController(http.Controller):

    @http.route('/skeen/api/v1/available_slots', type='json', auth='api_key', methods=['POST'])
    def get_available_slots(self, service_id, date_from, date_to, **kw):
        slots = request.env['salon.booking'].get_available_slots(
            service_id=service_id, date_from=date_from, date_to=date_to
        )
        return {'status': 'success', 'slots': slots}

    @http.route('/skeen/api/v1/create_appointment', type='json', auth='api_key', methods=['POST'])
    def create_appointment(self, phone, name, service_id, date, time, **kw):
        partner = request.env['res.partner'].search([('phone', '=', phone)], limit=1)
        if not partner:
            partner = request.env['res.partner'].create({
                'name': name, 'phone': phone, 'is_patient': True
            })
        booking = request.env['salon.booking'].create({
            'partner_id': partner.id,
            'service_id': service_id,
            'date': date,
            'time': time,
            'state': 'confirmed'
        })
        return {'status': 'success', 'booking_id': booking.id, 'reference': booking.name}

    @http.route('/skeen/api/v1/patient_balance', type='json', auth='api_key', methods=['POST'])
    def get_patient_balance(self, phone, **kw):
        partner = request.env['res.partner'].search([('phone', '=', phone)], limit=1)
        if not partner:
            return {'status': 'error', 'message': 'Paciente no encontrado'}
        pending_invoices = request.env['account.move'].search_read(
            [('partner_id', '=', partner.id), ('payment_state', '!=', 'paid')],
            ['amount_residual', 'name']
        )
        wallet = request.env['skeen.monedero'].get_balance(partner.id)
        return {
            'status': 'success',
            'pending_balance': sum(inv['amount_residual'] for inv in pending_invoices),
            'pending_invoices': pending_invoices,
            'wallet_points': wallet['points'],
            'wallet_mxn': wallet['equivalent_mxn']
        }

    @http.route('/skeen/api/v1/wallet_redeem', type='json', auth='api_key', methods=['POST'])
    def redeem_wallet(self, phone, points, appointment_id=None, **kw):
        return request.env['skeen.monedero'].redeem_points(phone, points, appointment_id)

    @http.route('/skeen/api/v1/cancel_appointment', type='json', auth='api_key', methods=['POST'])
    def cancel_appointment(self, phone, booking_id=None, **kw):
        domain = [('partner_id.phone', '=', phone), ('state', '=', 'confirmed')]
        if booking_id:
            domain.append(('id', '=', booking_id))
        booking = request.env['salon.booking'].search(domain, order='date asc', limit=1)
        if not booking:
            return {'status': 'error', 'message': 'No se encontro cita activa'}
        booking.write({'state': 'cancelled'})
        return {'status': 'success', 'cancelled_booking': booking.name}
```

**Plugin de Hermes para Odoo**

Ver archivo: `hermes/plugins/odoo_api_call.py`

### 6.3 Hermes ↔ WACRM: Comunicacion

Hermes y WACRM se comunican por dos canales:

**Canal 1: WACRM → Hermes (Webhooks outbound)**

Ver archivo: `hermes/webhooks/wacrm_webhook_server.py`

**Canal 2: Hermes → WACRM (API REST)**

Ver archivo: `hermes/plugins/wacrm_send.py`

### 6.4 WACRM ↔ Meta WhatsApp API: Configuracion

WACRM se conecta directamente a la API de Meta (Cloud API), sin intermediarios:

**Paso 1: Crear app en Meta Developers**

1. Ir a developers.facebook.com
2. Crear nueva app → Tipo: "Business" → Nombre: "SKEEN WhatsApp CRM"
3. Agregar producto "WhatsApp"
4. Configurar:
   - Phone Number ID: El numero de telefono de SKEEN
   - WhatsApp Business Account ID: El WABA ID
   - Access Token: Token de acceso permanente

**Paso 2: Configurar webhook en Meta**

| Campo | Valor |
|-------|-------|
| Callback URL | https://crm.skeen.mx/api/whatsapp/webhook |
| Verify Token | skeen_webhook_verify_2026 |
| Subscription fields | messages, message_template_status_update |

**Paso 3: Configurar WACRM**

En WACRM dashboard → Settings → WhatsApp:

| Campo | Origen |
|-------|--------|
| Phone Number ID | Meta Developers |
| Access Token | Token permanente (encriptado AES-256) |
| Business Account ID | WABA ID |
| Verify Token | skeen_webhook_verify_2026 |

**Paso 4: Templates de Meta aprobados**

| Template | Categoria | Uso |
|----------|-----------|-----|
| bienvenida_skeen | UTILITY | Primer contacto |
| confirmacion_cita | UTILITY | Confirmacion de agendamiento |
| recordatorio_cita | UTILITY | Recordatorio 24h antes |
| followup_tratamiento | UTILITY | Seguimiento post-tratamiento |
| reengage_skeen | MARKETING | Re-engagement pacientes inactivos |
| comprobante_pago | UTILITY | Confirmacion de pago recibido |

**Registrar webhook outbound de WACRM a Hermes**

```bash
curl -X POST https://crm.skeen.mx/api/v1/webhooks \
  -H "Authorization: Bearer wacrm_live_XXX" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hermes.skeen.mx/webhook/wacrm",
    "events": ["message.received", "message.status_updated", "conversation.created"]
  }'
```

---

## 7. Configuracion de WACRM

### 7.1 Fork y Self-Host

```bash
# PASO 1: Fork del repositorio
git clone https://github.com/SKEEN-DERMA/wacrm.git
cd wacrm

# PASO 2: Instalar dependencias
npm install
node -v  # v20.x o superior

# PASO 3: Configurar variables de entorno
cp .env.local.example .env.local

# Editar .env.local:
# NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
# NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJ...
# SUPABASE_SERVICE_ROLE_KEY=eyJ...
# ENCRYPTION_KEY=<64-hex-chars>
# WHATSAPP_PHONE_NUMBER_ID=123456789012345
# WHATSAPP_BUSINESS_ACCOUNT_ID=987654321098765
# WHATSAPP_ACCESS_TOKEN=EAA...
# WHATSAPP_VERIFY_TOKEN=skeen_webhook_verify_2026

# PASO 4: Configurar Supabase
# Crear proyecto en supabase.com
# Ejecutar migraciones en orden (001 a 028)
# Las migraciones 026_api_keys.sql y 028_webhook_endpoints.sql son REQUERIDAS

# PASO 5: Generar encryption key
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
# Output: 64 caracteres hex. NO cambiar despues.

# PASO 6: Configurar WhatsApp Business API en Meta Developers
# - Crear app, agregar producto WhatsApp
# - Registrar numero de telefono de SKEEN
# - Generar Access Token permanente (System User)
# - Configurar webhook con URL de WACRM

# PASO 7: Build y arrancar
npm run build
npm start
# Dev: npm run dev (localhost:3000)
```

### 7.2 Configuracion de Automatizaciones No-Code

En WACRM Dashboard → Automations, crear estos flows:

**Automatizacion 1: "Nuevo mensaje → Webhook Hermes"**

```
Trigger: "Primer mensaje de contacto" O "Mensaje recibido"
  |
  +-- Condition: Si es primer mensaje
  |     → Action: Enviar template "bienvenida_skeen"
  |     → Action: Esperar 5 segundos
  |
  +-- Action: Webhook → POST https://hermes.skeen.mx/webhook/wacrm
        Headers: X-WACRM-Event: message.received
        Body: { from, text, conversation_id, contact_id, is_first_message }
```

**Automatizacion 2: "Tag 'Cita-Confirmada' → Recordatorio"**

```
Trigger: "Tag cambiado" → Tag = "cita-confirmada"
  |
  +-- Action: Crear deal en pipeline "Citas" (stage: Confirmada)
  +-- Action: Webhook → POST https://hermes.skeen.mx/webhook/wacrm
        Body: { event: "appointment.confirmed", phone, service, date, time }
```

**Automatizacion 3: "Mensaje no respondido 30min → Alerta"**

```
Trigger: "Mensaje recibido"
  |
  +-- Action: Esperar 30 minutos
  +-- Condition: Si mensaje NO tiene respuesta del agente
        → Action: Asignar a agente disponible (round-robin)
        → Action: Tag "urgente-sin-respuesta"
```

### 7.3 Configuracion de AI Assistant

En WACRM Dashboard → Settings → AI Assistant:

| Campo | Valor |
|-------|-------|
| Provider | OpenAI |
| API Key | sk-proj-… (misma que Hermes o dedicada) |
| Model | gpt-4o-mini (para draft replies) |
| Auto-reply | OFF (Hermes maneja las respuestas) |
| Knowledge Base | Subir: "Manual de Servicios SKEEN" + "FAQ Pacientes" |
| Handoff trigger | Cuando el usuario escribe "AGENTE" o "HUMANO" |

**Nota:** WACRM AI Assistant es para draft replies de agentes humanos. Hermes es el agente autonomo principal. No activar auto-reply de WACRM para evitar conflictos con Hermes.

---

## 8. Configuracion de Hermes

### 8.1 Instalacion del Gateway

```bash
# PASO 1: Instalar Hermes globalmente
# Requisito: Python 3.11+
python3 --version  # 3.11+ requerido

# Instalar via script oficial
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# O instalar via pip
pip install "hermes-agent[messaging,cron,web]"

# Verificar instalacion
hermes --version  # v0.14.0+

# PASO 2: Configuracion inicial (setup wizard)
hermes setup
# - AI Provider: OpenAI
# - API Key: sk-proj-...
# - Model: gpt-4o
# - Platforms: Seleccionar webhook
# - Cron: YES

# PASO 3: Estructura post-setup
# ~/.hermes/
# ├── config.yaml          # Configuracion principal
# ├── plugins/
# │   ├── odoo_api_call.py   # Plugin Odoo
# │   └── wacrm_send.py      # Plugin WACRM
# └── workspace/
#     ├── AGENTS.md          # Instrucciones operativas
#     ├── SOUL.md            # Personalidad "Sofia"
#     ├── MEMORY.md          # Memoria persistente
#     ├── TOOLS.md           # Notas de tools
#     ├── IDENTITY.md        # Nombre/vibe/emoji
#     └── USER.md            # Perfil clinica

# PASO 4: Copiar config de SKEEN
cp /path/to/skeen-roadmap/hermes/config.yaml ~/.hermes/config.yaml

# PASO 5: Copiar plugins
cp /path/to/skeen-roadmap/hermes/plugins/*.py ~/.hermes/plugins/

# PASO 6: Copiar skills
cp -r /path/to/skeen-roadmap/hermes/skills/* ~/.hermes/skills/

# PASO 7: Configurar SOUL.md (personalidad "Sofia")
hermes personality set sofia
# O editar ~/.hermes/workspace/SOUL.md directamente

# PASO 8: Verificar configuracion
hermes doctor

# PASO 9: Iniciar Gateway (modo dev)
hermes gateway start

# PASO 10: Servicio systemd (produccion)
sudo tee /etc/systemd/system/hermes.service << 'EOF'
[Unit]
Description=Hermes Gateway — Agente IA SKEEN
After=network.target

[Service]
Type=simple
User=hermes
WorkingDirectory=/home/hermes
Environment=OPENAI_API_KEY=sk-proj-...
Environment=ANTHROPIC_API_KEY=sk-ant-...
Environment=ODOO_URL=http://odoo:8069
Environment=ODOO_DB=skeen
Environment=ODOO_API_KEY=...
Environment=WACRM_URL=http://wacrm:3000
Environment=WACRM_API_KEY=wacrm_live_...
Environment=HERMES_WEBHOOK_PORT=8080
ExecStart=/usr/local/bin/hermes gateway start
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable hermes
sudo systemctl start hermes
```

### 8.2 Cron para Recordatorios

Configuracion en `~/.hermes/config.yaml`:

```yaml
cron:
  enabled: true
  jobs:
    - name: recordatorios-citas
      schedule: "0 18 * * *"  # 6 PM diario
      command: "skill skeen-recordatorios --action send"
    - name: generar-recordatorios
      schedule: "0 */6 * * *"  # Cada 6 horas
      command: "skill skeen-recordatorios --action generate"
    - name: followups-semanal
      schedule: "0 10 * * 1"  # Lunes 10 AM
      command: "skill skeen-recordatorios --action followup"
    - name: reengagement-semanal
      schedule: "0 9 * * 1"  # Lunes 9 AM
      command: "skill skeen-recordatorios --action reengage"
```

La skill `skeen-recordatorios` tiene `metadata.hermes.always: true`, lo que la mantiene activa en cada ejecucion de cron.

| Intervalo | Accion | Skill |
|-------------|--------|-------|
| 6 PM diario | Enviar recordatorios pendientes | skeen-recordatorios |
| Cada 6h | Generar nuevos recordatorios | skeen-recordatorios |
| Lunes 10 AM | Follow-ups post-tratamiento | skeen-recordatorios |
| Lunes 9 AM | Re-engagement pacientes inactivos | skeen-recordatorios |

### 8.3 Integracion WACRM como Canal

En esta arquitectura WACRM es el canal principal. Hermes NO configura el canal WhatsApp nativo (Baileys). La comunicacion es:

```
Paciente → WhatsApp → Meta Cloud API → WACRM → Webhook → Hermes
                                                          |
Paciente ← WhatsApp ← Meta Cloud API ← WACRM ← API ← Respuesta IA
```

**Ventaja:** WACRM maneja toda la complejidad de Meta API (templates, rate limits, delivery tracking). Hermes se enfoca en la logica de negocio.

### 8.4 Monitoreo del Gateway

```bash
# Estado del gateway
hermes gateway status

# Ver logs
hermes logs --follow

# Health check
curl http://localhost:8080/health

# Listar cron jobs
hermes cron list

# Reiniciar gateway
hermes gateway restart

# Ver plataformas activas
hermes platforms

# Diagnosticar
hermes doctor
```

---

## 9. Roadmap Actualizado por Fase

**Fecha de inicio:** 5 de julio 2026 (hoy)
**Fecha de fin:** 24 de agosto 2026 (8 semanas)
**Equipo:** 2-3 desarrolladores (Dev 1: WACRM/Infra, Dev 2: Odoo/Backend, Dev 3: Hermes/Frontend)

### FASE 1: WACRM + Hermes Base (5 julio — 13 julio) | 9 dias

**Objetivo:** Tener WACRM operativo con WhatsApp, Hermes configurado como agente IA, y la comunicacion basica WACRM ↔ Hermes funcionando.

#### Semana 1 — Dias 1-5 (5 jul — 9 jul)

| Dia | Fecha | Tarea | Responsable | Entregable |
|-----|-------|-------|-------------|------------|
| 1 | Sab 5 jul | Fork de WACRM + setup local + Supabase project + migraciones base | Dev 1 | WACRM corriendo en localhost |
| 1 | Sab 5 jul | Crear app en Meta Developers + registrar numero de SKEEN + obtener tokens | Dev 1 | Phone ID + Access Token + WABA ID |
| 2 | Dom 6 jul | Configurar WhatsApp en WACRM + webhook verification + enviar primer mensaje de prueba | Dev 1 | "Hola Mundo" via WACRM → WhatsApp |
| 2 | Dom 6 jul | Instalar Hermes + setup wizard + configurar gateway | Dev 3 | Gateway corriendo en :8080 |
| 3 | Lun 7 jul | Configurar SOUL.md (personalidad "Sofia") + AGENTS.md (instrucciones) | Dev 3 | Personalidad definida y testeada |
| 3 | Lun 7 jul | Crear skill skeen-rag (catalogo de servicios) + JSON de servicios | Dev 3 | Skill funcional con test unitario |
| 4 | Mar 8 jul | Crear plugin odoo_api_call.py (conexion XML-RPC con Odoo) | Dev 2 | Plugin conectando con Odoo de prueba |
| 4 | Mar 8 jul | Crear plugin wacrm_send.py (envio de mensajes) | Dev 3 | Plugin funcional |
| 5 | Mie 9 jul | Crear servidor webhook en Hermes (recibir de WACRM) | Dev 3 | WACRM ↔ Hermes comunicacion bidireccional |
| 5 | Mie 9 jul | Crear skill skeen-agendar v1 (consultar disponibilidad) | Dev 3 | Skill + test de integracion |
| 5 | Mie 9 jul | Subir templates de Meta para aprobacion (bienvenida, confirmacion, recordatorio) | Dev 1 | Templates submitted en Meta |

#### Semana 2 — Dias 6-9 (10 jul — 13 jul)

| Dia | Fecha | Tarea | Responsable | Entregable |
|-----|-------|-------|-------------|------------|
| 6 | Jue 10 jul | Deploy de WACRM en VPS Hetzner (Docker) + Nginx + SSL | Dev 1 | crm.skeen.mx en produccion |
| 6 | Jue 10 jul | Deploy de Hermes gateway en VPS (Docker + systemd) | Dev 3 | hermes.skeen.mx en produccion |
| 7 | Vie 11 jul | Integracion WACRM webhook → Hermes en produccion + end-to-end test | Dev 1 + Dev 3 | Mensaje paciente → Sofia responde (automatizado) |
| 7 | Vie 11 jul | Crear skill skeen-pagos v1 (Stripe Checkout links) | Dev 3 | Generacion de links de pago funcional |
| 8 | Sab 12 jul | Configurar automatizaciones no-code en WACRM (nuevo mensaje → webhook Hermes) | Dev 1 | Automatizacion activa en produccion |
| 8 | Sab 12 jul | Crear skill skeen-monedero v1 (consulta saldo) | Dev 3 | Skill funcional |
| 9 | Dom 13 jul | Testing completo Fase 1 + bug fixes + documentacion | Todos | Reporte de testing + fixes aplicados |

#### Checkpoint Fase 1

- [x] WACRM desplegado en crm.skeen.mx con WhatsApp activo
- [x] Hermes gateway corriendo como daemon
- [x] Sofia (Hermes) responde mensajes de WhatsApp via WACRM
- [x] Skills: skeen-rag, skeen-agendar, skeen-pagos, skeen-monedero funcionales
- [x] Templates de Meta aprobados (bienvenida, confirmacion, recordatorio)
- [x] Automatizacion no-code: mensaje nuevo → webhook → Hermes
- [x] Plugins: odoo_api_call, wacrm_send funcionales

### FASE 2: Odoo + Frontend (14 julio — 3 agosto) | 21 dias

**Objetivo:** Odoo 17 desplegado con modulos custom, frontend React con dashboard de clinicas, y sincronizacion basica WACRM ↔ Odoo.

#### Semana 3 — Dias 10-14 (14 jul — 18 jul)

| Dia | Fecha | Tarea | Responsable | Entregable |
|-----|-------|-------|-------------|------------|
| 10 | Lun 14 jul | Instalar Odoo 17 Community en VPS + PostgreSQL + Redis | Dev 2 | Odoo corriendo en erp.skeen.mx |
| 10 | Lun 14 jul | Crear modulos Odoo: skeen_pacientes (res.partner extendido) | Dev 2 | Modulo instalado con campos custom |
| 11 | Mar 15 jul | Modulo skeen_citas (salon.booking extendido) + disponibilidad | Dev 2 | Calendario de citas funcional |
| 11 | Mar 15 jul | Frontend: Setup React 18 + Vite + Tailwind + routing basico | Dev 3 | App corriendo en localhost:5173 |
| 12 | Mie 16 jul | Modulo skeen_monedero (sistema de puntos/fidelidad) | Dev 2 | Monedero con acumulacion/redencion |
| 12 | Mie 16 jul | Frontend: Auth con Odoo + pantalla login + dashboard layout | Dev 3 | Login funcional + layout principal |
| 13 | Jue 17 jul | Modulo skeen_pagos (integracion Stripe + MercadoPago webhooks) | Dev 2 | Webhooks de pago funcionando |
| 13 | Jue 17 jul | Frontend: Pantalla de agenda/citas + calendario | Dev 3 | Calendario interactivo de citas |
| 14 | Vie 18 jul | Modulo skeen_whatsapp (controladores API para Hermes) | Dev 2 | Endpoints JSON-RPC funcionales |
| 14 | Vie 18 jul | Frontend: Pantalla de pacientes + busqueda + filtros | Dev 3 | Lista de pacientes funcional |

#### Semana 4 — Dias 15-19 (19 jul — 23 jul)

| Dia | Fecha | Tarea | Responsable | Entregable |
|-----|-------|-------|-------------|------------|
| 15 | Sab 19 jul | Conectar Hermes con Odoo en produccion (endpoints reales) | Dev 2 + Dev 3 | Hermes consulta Odoo en prod |
| 15 | Sab 19 jul | Actualizar skill skeen-agendar para usar endpoints de produccion | Dev 3 | Agendamiento end-to-end funcional |
| 16 | Dom 20 jul | Frontend: Pantalla de pagos + integracion Stripe Checkout | Dev 3 | Links de pago generados desde frontend |
| 16 | Dom 20 jul | Sincronizacion contactos WACRM ↔ Odoo (plugin cron) | Dev 1 | Sync bidireccional cada 5 min |
| 17 | Lun 21 jul | Frontend: Pantalla de monedero + historial de puntos | Dev 3 | Monedero digital visual |
| 17 | Lun 21 jul | Skill skeen-recordatorios v1 (cron basico) | Dev 3 | Recordatorios 24h antes funcionando |
| 18 | Mar 22 jul | Frontend: Reportes + analytics (citas, ingresos, pacientes nuevos) | Dev 3 | Dashboard con charts |
| 18 | Mar 22 jul | WACRM: Configurar pipelines Kanban para leads de WhatsApp | Dev 1 | Pipeline: Lead → Consulta → Tratamiento → Recurrente |
| 19 | Mie 23 jul | Testing Fase 2 + integracion WACRM-Odoo-Frontend | Todos | Test suite pasando |

#### Semana 5 — Dias 20-24 (24 jul — 28 jul)

| Dia | Fecha | Tarea | Responsable |
|-----|-------|-------|-------------|
| 20 | Jue 24 jul | WACRM: Configurar AI Assistant con knowledge base de SKEEN | Dev 1 |
| 21 | Vie 25 jul | Frontend: Responsive design + mobile optimization | Dev 3 |
| 22 | Sab 26 jul | Seguridad: Rate limiting, input validation, audit logs | Dev 2 |
| 23 | Dom 27 jul | Optimizacion: Caching Redis, query optimization, lazy loading | Dev 2 + Dev 3 |
| 24 | Lun 28 jul | Buffer + bug fixes + pulido de UX | Todos |

#### Semana 6 — Dias 25-28 (29 jul — 1 ago)

| Dia | Fecha | Tarea | Responsable |
|-----|-------|-------|-------------|
| 25 | Mar 29 jul | WACRM: Configurar broadcast campaigns (promos, newsletters) | Dev 1 |
| 26 | Mie 30 jul | Hermes: Follow-ups post-tratamiento (7 dias) via cron | Dev 3 |
| 27 | Jue 31 jul | Hermes: Re-engagement pacientes inactivos (90 dias) | Dev 3 |
| 28 | Vie 1 ago | Testing completo + performance testing | Todos |

#### Checkpoint Fase 2

- [x] Odoo 17 desplegado con 5 modulos custom funcionales
- [x] Frontend React con dashboard, agenda, pacientes, pagos, monedero
- [x] Hermes integrado con Odoo en produccion (XML-RPC)
- [x] Skills actualizados para endpoints reales
- [x] Sincronizacion WACRM ↔ Odoo automatica
- [x] Recordatorios automaticos funcionando (via hermes cron)
- [x] Pagos Stripe + MercadoPago integrados

### FASE 3: Integracion Completa + Go-Live (4 agosto — 24 agosto) | 21 dias

**Objetivo:** Todos los sistemas integrados, testing final, capacitacion del equipo SKEEN, y go-live productivo.

#### Semana 7 — Dias 29-32 (4 ago — 7 ago)

| Dia | Fecha | Tarea | Responsable |
|-----|-------|-------|-------------|
| 29 | Lun 4 ago | Integracion completa: test end-to-end de todos los flujos | Todos |
| 30 | Mar 5 ago | WACRM: Configurar team accounts + roles (owner/admin/agent/viewer) | Dev 1 |
| 30 | Mar 5 ago | Onboarding de 2-3 recepcionistas/agentes de SKEEN en WACRM | Dev 1 |
| 31 | Mie 6 ago | Hermes: Tuning de prompts + optimizacion de respuestas | Dev 3 |
| 31 | Mie 6 ago | WACRM: Configurar flows (chatbot no-code para FAQs simples) | Dev 1 |
| 32 | Jue 7 ago | Testing con usuarios reales (recepcionistas de SKEEN) | Todos + Cliente |

#### Semana 8 — Dias 33-36 (8 ago — 12 ago)

| Dia | Fecha | Tarea | Responsable |
|-----|-------|-------|-------------|
| 33 | Vie 8 ago | Fixes post-testing con usuarios reales | Todos |
| 34 | Sab 9 ago | WACRM: Subir y aprobar templates restantes (follow-up, re-engage) | Dev 1 |
| 35 | Dom 10 ago | Monitoreo: Configurar Uptime Kuma + alertas (email/WhatsApp) | Dev 1 |
| 36 | Lun 11 ago | Backup strategy: PostgreSQL dumps diarios + Hermes workspace | Dev 2 |
| 36 | Mar 12 ago | Performance tuning: CDN, caching, DB indices, connection pooling | Dev 2 |

#### Semana 9 — Dias 37-41 (13 ago — 17 ago)

| Dia | Fecha | Tarea | Responsable |
|-----|-------|-------|-------------|
| 37 | Mie 13 ago | Capacitacion equipo SKEEN: WACRM inbox + pipelines + broadcasts | Todos + Cliente |
| 38 | Jue 14 ago | Capacitacion equipo SKEEN: Frontend dashboard + Odoo backend | Todos + Cliente |
| 39 | Vie 15 ago | Documentacion final: guias de uso + troubleshooting | Todos |
| 40 | Sab 16 ago | Soft launch: sistema activo con soporte nuestro presente | Todos |
| 41 | Dom 17 ago | Monitoreo intenso + ajustes finos + pulido | Todos |

#### Semana 10 — Dias 42-47 (18 ago — 24 ago)

| Dia | Fecha | Tarea | Responsable |
|-----|-------|-------|-------------|
| 42 | Lun 18 ago | Handoff gradual: SKEEN toma control con nuestro soporte remoto | Todos |
| 43-46 | Mar-Vie | Soporte activo + monitoreo + ajustes menores | Todos |
| 47 | Dom 24 ago | GO-LIVE OFICIAL + cierre de proyecto | Todos + Cliente |

#### Checkpoint Fase 3 (Proyecto Completo)

- [x] Integracion completa WACRM + Hermes + Odoo + Frontend
- [x] Team accounts configurados en WACRM
- [x] Equipo SKEEN capacitado
- [x] Monitoreo y alertas activos
- [x] Backup strategy implementado
- [x] Soft launch exitoso
- [x] Go-live oficial
- [x] Documentacion entregada

### Gantt Chart Resumido

```
Julio 2026                           Agosto 2026
5  8  11  14  17  20  23  26  29  1 | 4  7  10  13  16  19  22  24
|==== FASE 1 ====|                   |
|WACRM setup      |                   |
|Hermes config    |                   |
|Skills v1        |                   |
|Meta templates   |                   |
                 |===== FASE 2 ======|
                 |Odoo modules        |
                 |Frontend React      |
                 |Hermes-Odoo integ  |
                 |WACRM-Odoo sync    |
                                     |==== FASE 3 ======|
                                     |E2E testing       |
                                     |Capacitacion      |
                                     |Soft launch       |
                                     |Go-live           |
```

---

## 10. Ventajas y Desventajas de esta Arquitectura

### 10.1 Pros de WACRM vs Twilio + Inbox Custom

| Aspecto | WACRM | Twilio + Custom |
|---------|-------|-----------------|
| Tiempo de desarrollo | Inbox listo dia 1 | 2-3 semanas de desarrollo |
| Costo | MIT (gratis), solo hosting | Twilio fees $0.005/msg + desarrollo |
| Shared inbox | Nativo multi-agente | A construir desde cero |
| Pipelines Kanban | Nativo con drag-drop | A construir |
| Automatizaciones | Visual builder no-code | Todo en codigo |
| Broadcasts | Nativo con templates Meta | API calls custom |
| Dashboard | Real-time nativo | A construir |
| AI Assistant | Built-in con BYOK | Integracion manual |
| Team accounts | Nativo (invite por link) | Sistema de auth custom |
| API REST publica | /api/v1 completa | A construir |
| Mobile-responsive | Si (Next.js 16 + Tailwind) | Depende de implementacion |
| Community | GitHub 1.2k stars, activo | Solo tu equipo |

### 10.2 Pros de Hermes vs OpenClaw / FastAPI + GPT-4o Directo

| Aspecto | Hermes | OpenClaw | FastAPI + GPT-4o |
|---------|--------|----------|------------------|
| Arquitectura | Gateway Python con WS + API | Gateway Node.js WS | Servidor HTTP stateless |
| Memoria | SQLite + MEMORY.md + plugins | Archivos Markdown | Stateless (cada request nueva) |
| Skills | Modulares (SKILL.md) — 166+ disponibles | Modulares (SKILL.md) | Codigo embebido en endpoints |
| Tools | 25+ built-in + plugins Python | 25+ built-in + custom JS | A implementar una por una |
| Cron | Nativo (`hermes cron`) | Heartbeat custom (30 min) | Solo reactivo (request/response) |
| Multi-model | OpenAI, Anthropic, Google, Ollama, 15+ providers | OpenAI, Anthropic, Ollama | Solo el que integres |
| Fallback providers | Nativo con cadena de failover | No | No |
| Context compression | Nativo — hasta 50% de ventana | No | No |
| Credential pools | Rotacion automatica de API keys | No | No |
| Subagentes | Si — delegacion aislada con terminal propio | No | No |
| Handoff humano | Nativo con triggers | Nativo | A implementar |
| Session management | SQLite con FTS5 search | Archivos MD | A implementar |
| API Server | OpenAI-compatible `/v1/chat/completions` | No | A construir |
| TUI | Ink-based interactivo | No | No |
| MCP | Cliente + servidor nativo | No | No |
| Voice | Push-to-talk, voice notes | No | No |
| Browser | Camofox, Browserbase, Browser Use | No | No |
| Agente autonomo | Si — puede actuar solo via cron | Si — heartbeat | No — solo responde requests |
| Community | 150k+ stars, 700+ skills, Nous Research | 150k+ stars (misma base) | Solo tu equipo |
| Skills Hub | agentskills.io + ClawHub | ClawHub | N/A |
| Costo | MIT (gratis), solo LLM fees | MIT (gratis), solo LLM fees | Desarrollo + hosting + LLM |
| Lenguaje | Python 3.11+ | Node.js 22+ | Python 3.10+ |

### 10.3 Ventajas Generales de la Nueva Arquitectura

1. **60% menos codigo custom:** WACRM inbox + Hermes skills vs construir todo desde cero
2. **Stack coherente:** WACRM usa Node.js (Next.js); Hermes usa Python — ambos con ecosistemas maduros
3. **Comunidad activa:** WACRM (1.2k stars) + Hermes (150k stars, Nous Research) = soporte continuo
4. **Self-host completo:** Codigo propio, datos propios, infra propia
5. **Escalable:** WACRM escala con Supabase; Hermes escala con gateway adicionales y profiles
6. **Modular:** Skills de Hermes se pueden agregar/cambiar sin redeploy; plugins Python hot-reload
7. **Sin vendor lock-in de Twilio:** API estandar de Meta, codigo MIT
8. **AI nativo:** Hermes esta disenado para agentes IA desde el ground up
9. **Proactive:** Cron nativo permite acciones sin input del usuario (recordatorios, follow-ups, re-engagement)
10. **Resiliente:** Fallback providers, credential pools, context compression — tolerancia a fallos built-in
11. **Costo predecible:** Hosting fijo + fees de Meta/OpenAI sin margenes de terceros

### 10.4 Riesgos y Mitigaciones

| Riesgo | Probabilidad | Impacto | Mitigacion |
|--------|-------------|---------|------------|
| Meta rechaza templates de WhatsApp | Media | Alto | Subir templates temprano (Fase 1 dia 5); tener mensajes de texto como fallback |
| WACRM tiene bugs en produccion | Media | Medio | Fork propio permite patches rapidos; community activa en GitHub issues |
| Hermes gateway se cae | Baja | Alto | systemd auto-restart; monitoreo Uptime Kuma; fallback a WACRM AI Assistant; fallback providers |
| Odoo XML-RPC lento | Media | Medio | Caching en Redis; batch queries; indices en DB |
| Equipo SKEEN no adopta WACRM | Media | Medio | Capacitacion hands-on; WACRM tiene UX intuitiva; soporte primeras 2 semanas |
| Costo OpenAI API excede presupuesto | Baja | Medio | Implementar rate limiting; fallback a GPT-4o-mini; monitoreo de uso; credential pools |
| Supabase limites en tier gratuito | Baja | Medio | Migrar a tier Pro ($25/mes) si se excede; o self-host Supabase |
| Numero WhatsApp de SKEEN bloqueado | Baja | Alto | Seguir guidelines de Meta; templates aprobados; no spam; opt-in explicito |
| Dependencia de proyectos open-source | Media | Medio | Ambos MIT license; codigo propio en fork; comunidades grandes y activas |
| Integracion WACRM ↔ Hermes compleja | Media | Medio | Webhook simple con firma HMAC; API REST bien documentada; testing temprano |
| Python 3.11+ no disponible en VPS | Baja | Alto | Usar Docker con imagen base Python 3.11; o pyenv |

### 10.5 Estrategia de Contingencia

Si algun componente falla irreparablemente:

- **WACRM cae:** Fallback a Hermes con canal WhatsApp directo (Baileys) + inbox manual
- **Hermes cae:** WACRM AI Assistant toma el control con auto-reply basico + handoff a humano; fallback providers mantienen LLM activo
- **Odoo cae:** WACRM + Hermes pueden operar con datos locales (SQLite) hasta restaurar
- **Meta API cae:** No hay alternativa (es la infraestructura de WhatsApp), esperar
- **OpenAI cae:** Hermes fallback providers activan Claude, OpenRouter, o modelos locales (Ollama/LM Studio)

---

## 11. Requisitos del Cliente (Actualizados)

### 11.1 De SKEEN Derma Experts — Para Comenzar

| Requisito | Prioridad | Entrega Esperada | Notas |
|-----------|-----------|------------------|-------|
| Numero de telefono de WhatsApp Business | CRITICA | Dia 1 (5 jul) | Debe estar verificado por Meta |
| Cuenta Meta Business | CRITICA | Dia 1 | Para registrar la app de WhatsApp |
| Logo y branding | Alta | Semana 1 | Para personalizar WACRM (fork) |
| Lista de servicios y precios | CRITICA | Semana 1 | Para skill skeen-rag y Odoo |
| Horarios de atencion | CRITICA | Semana 1 | Para skill skeen-agendar |
| Datos de 5-10 pacientes de prueba | Alta | Semana 2 | Para testing de agendamiento |
| Acceso a Stripe account | Media | Semana 2 | Para integracion de pagos |
| Acceso a MercadoPago account | Media | Semana 2 | Para pagos en Mexico |
| Fotos de la clinica | Baja | Semana 3 | Para templates de WhatsApp |
| FAQ comunes de pacientes | Alta | Semana 1 | Para knowledge base de Sofia |
| Designar 2-3 recepcionistas | Alta | Semana 7 | Para capacitacion WACRM inbox |
| Dominio skeen.mx | CRITICA | Dia 1 | Para DNS y subdominios |

### 11.2 Informacion Tecnica Requerida

```bash
# Datos que necesitamos de SKEEN antes del dia 1:

# 1. NUMERO WHATSAPP BUSINESS
#    - Numero de telefono (formato internacional: +52...)
#    - Debe estar verificado en Meta Business
#    - Tipo: numero de telefono fijo o movil del negocio

# 2. META BUSINESS ACCOUNT
#    - Business Manager ID
#    - Admin access para crear apps
#    - O invitarnos como desarrolladores

# 3. SERVICIOS (JSON o Excel)
[
  { "name": "Consulta Dermatologica", "price": 800, "duration": 30, "category": "consulta" },
  { "name": "Tratamiento Facial Acne", "price": 1500, "duration": 60, "category": "tratamiento" },
  ...
]

# 4. HORARIOS
#    - Lun-Vie: 9:00-18:00 (o el que aplique)
#    - Sab: 9:00-14:00
#    - Feriados / dias cerrados

# 5. PERSONAL MEDICO
#    - Nombre del dermatologo/a principal
#    - Especialidades
#    - Horarios especificos por doctor

# 6. STRIPE / MERCADOPAGO
#    - Stripe: Secret key + Publishable key
#    - MercadoPago: Access token + Public key

# 7. DOMINIO Y DNS
#    - Acceso a DNS de skeen.mx (o delegarnos subdomain)
#    - Subdominios necesarios: crm, erp, app, hermes
```

---

## 12. Presupuesto de Infraestructura Actualizado

### 12.1 Costos Mensuales Recurrentes

| Servicio | Costo Mensual (USD) | Costo Mensual (MXN) | Notas |
|----------|---------------------|---------------------|-------|
| VPS Hetzner CPX31 | $15.00 | ~$270 | 4 vCPU / 8 GB RAM / 160 GB SSD |
| Supabase (Pro tier) | $25.00 | ~$450 | PostgreSQL + Auth + Storage + Realtime |
| Meta WhatsApp Cloud API | $5-50 | ~$90-$900 | Variable: $0.003-0.008 por conversacion |
| OpenAI API (GPT-4o) | $20-80 | ~$360-$1,440 | Variable: ~500-2000 conversaciones/mes |
| Stripe | $0 base | $0 | Solo fees por transaccion (2.9% + $0.30) |
| MercadoPago | $0 base | $0 | Solo fees por transaccion (3.5-4.5%) |
| Cloudflare (Free) | $0 | $0 | DNS + CDN + DDoS protection |
| Let's Encrypt | $0 | $0 | SSL certificates gratis |
| Uptime Kuma | $0 | $0 | Self-hosted, open source |
| Dominio skeen.mx | $1-2 | ~$20-40 | ~$12-20 USD/ano |
| Backup storage | $3-5 | ~$55-90 | Hetzner Storage Box para dumps |
| **TOTAL MENSUAL (base)** | **~$68** | **~$1,224** | Con volumen bajo |
| **TOTAL MENSUAL (promedio)** | **~$130** | **~$2,340** | Con ~500 conversaciones/mes |
| **TOTAL MENSUAL (alto)** | **~$200** | **~$3,600** | Con ~2000 conversaciones/mes |

### 12.2 Comparativa de Costos: Original vs Nueva

| Concepto | Original (Twilio + Custom) | Nueva (WACRM + Hermes) | Ahorro |
|----------|---------------------------|------------------------|--------|
| WhatsApp messaging (500 conversaciones) | $25 (Twilio) | $15 (Meta directo) | 40% |
| Inbox/CRM hosting | $20 (infra custom) | $25 (Supabase Pro) | -25% (pero sin dev) |
| Desarrollo inbox (amortizado 12 meses) | $400/mes | $0 | 100% |
| Agente IA backend | $30 (infra custom) | $20 (Hermes + OpenAI) | 33% |
| Desarrollo agente IA (amortizado 12 meses) | $600/mes | $100/mes | 83% |
| CRM/Contactos | $10 (infra) | Incluido en Supabase | 100% |
| Dashboard analytics | $15 (infra) | Incluido en WACRM | 100% |
| **Total mensual (con desarrollo amortizado)** | **~$1,100** | **~$180** | **~84%** |
| **Total mensual (solo infra + APIs)** | **~$100** | **~$80** | **20%** |

### 12.3 Costo de Desarrollo (8 semanas)

El contrato de $182,500 MXN se mantiene. La redistribucion del esfuerzo:

| Fase | Esfuerzo Estimado | Notas |
|------|-------------------|-------|
| Fase 1: WACRM + Hermes Base | 25% del esfuerzo | WACRM listo reduce tiempo significativamente |
| Fase 2: Odoo + Frontend | 45% del esfuerzo | Similar al plan original |
| Fase 3: Integracion + Go-Live | 20% del esfuerzo | Testing + capacitacion |
| Buffer (10%) | 10% del esfuerzo | Para imprevistos |

**Ahorro de tiempo estimado:** ~2-3 semanas menos de desarrollo gracias a WACRM inbox + Hermes tools/skills/cron listos. Esto permite:
- Mas tiempo para pulir la experiencia de usuario
- Mas capacitacion del equipo SKEEN
- Mejor testing de integraciones
- Features extra (broadcasts, flows, subagentes)

### 12.4 Proyeccion a 12 Meses

| Mes | Conversaciones | Costo Infra (USD) | Costo APIs (USD) | Total (USD) | Total (MXN) |
|-----|---------------|-------------------|------------------|-------------|-------------|
| Mes 1-2 (lanzamiento) | 100-200 | $68 | $30 | $98 | ~$1,764 |
| Mes 3-6 (crecimiento) | 300-500 | $68 | $65 | $133 | ~$2,394 |
| Mes 7-12 (estable) | 500-1000 | $68 | $120 | $188 | ~$3,384 |
| **Promedio anual** | **~500/mes** | **$816** | **$1,050** | **$1,866** | **~$33,588** |

### 12.5 ROI Estimado para SKEEN

| Metrica | Valor |
|---------|-------|
| Reduccion no-shows (recordatorios automaticos) | ~30-40% menos citas perdidas |
| Aumento re-agendamiento (re-engagement 90d) | ~15-20% pacientes recuperados |
| Tiempo recepcionista ahorrado | ~10-15 hrs/semana en agendamiento manual |
| Mejora satisfaccion paciente | Respuesta inmediata 24/7 via Sofia |
| Ingreso adicional estimado | $5,000-$15,000 MXN/mes (menos no-shows + re-engagement) |
| Payback de inversion | ~2-3 meses |

---

## Apendice A: Glosario de Terminos

| Termino | Definicion |
|---------|------------|
| WACRM | CRM open-source para WhatsApp. Shared inbox, pipelines, broadcasts, automatizaciones. |
| Hermes | Agente de IA autonomo open-source por Nous Research. Gateway Python con skills, tools, memoria, cron. |
| SKILL.md | Archivo Markdown que define una capacidad del agente (instrucciones + metadata YAML). Compatible con agentskills.io. |
| SOUL.md | Archivo que define la personalidad, tono y limites del agente Hermes. |
| AGENTS.md | Archivo con instrucciones operativas del agente (flujos de trabajo). |
| Cron | Sistema de tareas programadas nativo de Hermes (`hermes cron`). |
| Meta Cloud API | API oficial de WhatsApp Business (antes WhatsApp Business API). |
| BYOK | Bring Your Own Key — usar tu propia API key de OpenAI/Anthropic. |
| Supabase | Backend-as-a-Service open-source (PostgreSQL + Auth + Storage + Realtime). |
| RLS | Row-Level Security — seguridad a nivel de fila en PostgreSQL. |
| Webhook | HTTP callback — un sistema notifica a otro via POST cuando ocurre un evento. |
| HMAC-SHA256 | Algoritmo de firma criptografica para verificar autenticidad de webhooks. |
| Template (Meta) | Mensaje pre-aprobado por Meta para enviar via WhatsApp Business API. |
| Pipeline (Kanban) | Tablero visual de etapas para seguimiento de leads/deals. |
| Broadcast | Envio masivo de mensajes a una lista de contactos. |
| Monedero digital | Sistema de puntos/fidelidad acumulados por compras. |
| Handoff | Transferencia de conversacion de IA a agente humano. |
| Fallback providers | Cadena de proveedores LLM de respaldo en Hermes. |
| Credential pools | Rotacion automatica de multiples API keys del mismo proveedor. |
| Context compression | Compresion nativa de contexto en Hermes para conversaciones largas. |
| Subagentes | Agentes aislados delegados por Hermes para tareas paralelas. |
| MCP | Model Context Protocol — estandar de integracion de herramientas. |
| Profile | Instancia aislada de Hermes con su propia config, memoria y skills. |

## Apendice B: Recursos y Referencias

| Recurso | URL |
|---------|-----|
| WACRM GitHub | https://github.com/ArnasDon/wacrm |
| WACRM Docs | https://wacrm.tech/docs |
| WACRM Public API | https://wacrm.tech/docs/public-api |
| Hermes Agent (Nous Research) | https://hermes-agent.nousresearch.com |
| Hermes Docs | https://hermes-agent.nousresearch.com/docs |
| Hermes GitHub | https://github.com/NousResearch/hermes-agent |
| Skills Hub (agentskills.io) | https://agentskills.io |
| Meta WhatsApp Cloud API | https://developers.facebook.com/docs/whatsapp/cloud-api |
| Supabase | https://supabase.com |
| Odoo 17 | https://www.odoo.com/documentation/17.0 |
| Stripe Mexico | https://stripe.com/mx |
| MercadoPago Developers | https://www.mercadopago.com.mx/developers |

## Apendice C: Checklist de Go-Live

### T-7 dias (17 ago)

- [ ] Todos los servicios desplegados y saludables
- [ ] Monitoreo activo (Uptime Kuma)
- [ ] Alertas configuradas (email + WhatsApp)
- [ ] Backup automatizado probado
- [ ] SSL certificates validos
- [ ] DNS configurado correctamente
- [ ] Hermes gateway estable (hermes doctor pasa)
- [ ] Cron jobs activos y verificados

### T-3 dias (21 ago)

- [ ] Templates de Meta todos aprobados
- [ ] Sofia responde correctamente a 20+ escenarios de prueba
- [ ] Agendamiento end-to-end funcional
- [ ] Pagos (Stripe + MP) funcionan
- [ ] Monedero acumula y redime puntos
- [ ] Recordatorios automaticos enviados correctamente
- [ ] WACRM inbox con team accounts y roles
- [ ] Fallback providers configurados y probados

### T-1 dia (23 ago)

- [ ] Equipo SKEEN tiene accesos y credenciales
- [ ] Guia de usuario entregada
- [ ] Canales de soporte establecidos
- [ ] Rollback plan documentado
- [ ] Comunicacion a pacientes preparada (mensaje de lanzamiento)
- [ ] Hermes memory respaldada
- [ ] Plugins y skills verificados

### T-0 (24 ago) — GO-LIVE

- [ ] Activar webhook de produccion
- [ ] Confirmar primer mensaje de paciente real procesado
- [ ] Monitoreo intenso primeras 4 horas
- [ ] Soporte remoto disponible
- [ ] Verificar cron jobs ejecutando correctamente
- [ ] Confirmar fallback providers activos

---

**Documento elaborado:** 5 de julio 2026
**Version:** 3.0 — Arquitectura Actualizada (WACRM + Hermes + Odoo)
**Proxima revision:** Al cierre de Fase 1 (13 julio 2026)
**Autor:** Equipo de desarrollo SKEEN Derma Experts
