@innvisor/conny-ai 9.7.0

package/v7/orchestrator.py

@@ -0,0 +1,275 @@
+"""
+Conny V7.0 — Orquestador
+============================
+Conecta router, memoria, agentes y postprocessor.
+conny.py llama a orchestrator.process() en lugar de generator.generate().
+Si algo falla, cae al generator clásico (backward compat).
+
+"todo debe actuar como uno" — el paciente nunca sabe qué agente respondió.
+"""
+
+from __future__ import annotations
+import asyncio
+import logging
+import time
+from typing import Dict, List, Optional, Any
+
+from v7.router             import router, AgentID, RouterResult
+from v7.agents             import build_registry
+from v7.agents.base        import AgentContext, AgentResponse
+from v7.memory.patient_profile import ProfileStore, PatientProfile, FunnelStage
+from v7.postprocess        import postprocess, split_bubbles
+
+log = logging.getLogger(__name__)
+
+
+class ConnyOrchestrator:
+    """
+    Orquestador central de Conny V7.
+    Se instancia una vez al arranque de ConnyUltra.
+    """
+
+    def __init__(self, llm_engine, db):
+        self._agents       = build_registry(llm_engine)
+        self._profile_store = ProfileStore(db)
+        self._llm          = llm_engine
+        self._db           = db
+        log.info(
+            "[orchestrator] V7 listo. Agentes: %s",
+            list(self._agents.keys())
+        )
+
+    async def process(
+        self,
+        chat_id:   str,
+        text:      str,
+        clinic:    Dict,
+        patient:   Dict,
+        history:   List[Dict],
+        search_context: str = "",
+        kb_context:     str = "",
+        calendar_info:  str = "",
+        is_cron:   bool = False,
+        cron_type: Optional[str] = None,
+    ) -> List[str]:
+        """
+        Punto de entrada principal.
+        Devuelve lista de burbujas lista para enviar.
+        """
+        t0 = time.perf_counter()
+
+        # 1. Cargar perfil del paciente
+        profile = self._profile_store.load(chat_id)
+
+        # 2. Routing de intención
+        route = router.route(
+            text=text,
+            funnel_state=profile.funnel_stage.value,
+            history_length=len(history),
+            is_cron=is_cron,
+            cron_type=cron_type,
+        )
+
+        log.info(
+            "[orchestrator] %s → agente=%s confianza=%.2f señales=%s funnel=%s",
+            chat_id[:8],
+            route.agent_id.value,
+            route.confidence,
+            route.signals[:2],
+            profile.funnel_stage.value,
+        )
+
+        # 3. Resolver agente
+        agent = self._agents.get(route.agent_id)
+        if not agent:
+            log.warning("[orchestrator] agente %s no encontrado, usando fallback", route.agent_id)
+            return None  # señal para que conny.py use el generator clásico
+
+        # 4. Ensamblar contexto mínimo
+        ctx = self._build_context(
+            chat_id=chat_id,
+            text=text,
+            clinic=clinic,
+            profile=profile,
+            history=history,
+            context_keys=route.context_keys,
+            search_context=search_context,
+            kb_context=kb_context,
+            calendar_info=calendar_info,
+            cron_metadata={"follow_up_reason": cron_type} if is_cron else {},
+        )
+
+        # 5. Ejecutar agente
+        response: AgentResponse = await agent.run(ctx)
+
+        # 6. Actualizar memoria (async, no bloquea la respuesta)
+        asyncio.create_task(
+            self._update_memory(profile, response, route)
+        )
+
+        # 7. Si el agente detectó escalación a humano → notificar
+        if response.next_agent == "human":
+            asyncio.create_task(
+                self._notify_escalation(chat_id, text, clinic)
+            )
+
+        latency = (time.perf_counter() - t0) * 1000
+        log.info(
+            "[orchestrator] %s completado en %.0fms (agente=%.0fms)",
+            chat_id[:8], latency, response.latency_ms
+        )
+
+        return response.bubbles
+
+    # ── Ensamblado de contexto ────────────────────────────────────────────────
+
+    def _build_context(
+        self,
+        chat_id:      str,
+        text:         str,
+        clinic:       Dict,
+        profile:      PatientProfile,
+        history:      List[Dict],
+        context_keys: List[str],
+        search_context: str,
+        kb_context:   str,
+        calendar_info: str,
+        cron_metadata: Dict,
+    ) -> AgentContext:
+        """
+        Ensambla SOLO los campos que el agente declaró necesitar.
+        Clave para mantener el prompt corto.
+        """
+        # Tone detection
+        clinic_tone = self._detect_tone(clinic)
+
+        # Servicios en texto compacto
+        servicios_raw = clinic.get("services", [])
+        if isinstance(servicios_raw, list):
+            servicios = ", ".join(
+                s.get("name", "") if isinstance(s, dict) else str(s)
+                for s in servicios_raw[:8]
+            )
+        else:
+            servicios = str(servicios_raw)[:200]
+
+        return AgentContext(
+            chat_id=chat_id,
+            text=text,
+            platform=str(clinic.get("platform") or "whatsapp"),
+            patient_summary=profile.to_context_summary(context_keys),
+            funnel_stage=profile.funnel_stage.value,
+            patient_name=profile.nombre,
+            visits=profile.visitas,
+            objeciones_pasadas=profile.objeciones_pasadas,
+            clinic_name=clinic.get("name", ""),
+            clinic_tone=clinic_tone,
+            clinic_kb=kb_context[:500] if kb_context else "",
+            servicios=servicios,
+            precios=self._extract_pricing(clinic)[:300],
+            history=history[-8:],
+            search_context=search_context[:400] if search_context else "",
+            calendar_info=calendar_info,
+            metadata=cron_metadata,
+        )
+
+    def _detect_tone(self, clinic: Dict) -> str:
+        name = clinic.get("name", "").lower()
+        ctx  = clinic.get("description", "").lower()
+        combined = name + " " + ctx
+
+        _premium_words = [
+            "hospital","las américas","pablo tobón","tobon","country",
+            "bocagrande","fundación","fundacion","universitario","cardiovascular",
+            "premium","internacional","vip","élite","elite",
+        ]
+        _health_words = [
+            "clínica","clinica","médico","medico","salud","consultorio",
+            "odontología","dental","psicología","terapia","estetica","estética",
+        ]
+        _retail_words = [
+            "tienda","almacén","almacen","muebles","ropa","calzado",
+            "restaurante","cafetería","ferretería",
+        ]
+
+        is_health   = any(w in combined for w in _health_words)
+        is_premium  = any(w in combined for w in _premium_words)
+        is_retail   = any(w in combined for w in _retail_words)
+
+        if is_health and is_premium:
+            return "SALUD PREMIUM"
+        elif is_health:
+            return "SALUD"
+        elif is_premium:
+            return "PREMIUM"
+        elif is_retail:
+            return "RETAIL"
+        return "GENERAL"
+
+    def _extract_pricing(self, clinic: Dict) -> str:
+        pricing = clinic.get("pricing", {})
+        if not pricing:
+            return ""
+        if isinstance(pricing, dict):
+            lines = [f"{k}: {v}" for k, v in list(pricing.items())[:5]]
+            return "\n".join(lines)
+        return str(pricing)[:300]
+
+    # ── Actualización de memoria ──────────────────────────────────────────────
+
+    async def _update_memory(
+        self,
+        profile:  PatientProfile,
+        response: AgentResponse,
+        route:    RouterResult,
+    ) -> None:
+        """Actualiza el perfil del paciente con lo aprendido en este turno."""
+        try:
+            changed = False
+
+            if response.funnel_update:
+                try:
+                    new_stage = FunnelStage(response.funnel_update)
+                    if profile.advance_funnel(new_stage):
+                        changed = True
+                except ValueError:
+                    pass
+
+            if response.new_objecion:
+                profile.add_objecion(response.new_objecion)
+                changed = True
+
+            if response.learned_name:
+                profile.nombre = response.learned_name
+                changed = True
+
+            if response.learned_zona:
+                profile.add_zona(response.learned_zona)
+                changed = True
+
+            if changed:
+                self._profile_store.save(profile)
+
+        except Exception as e:
+            log.warning("[orchestrator] error actualizando memoria: %s", e)
+
+    async def _notify_escalation(
+        self, chat_id: str, text: str, clinic: Dict
+    ) -> None:
+        """Notifica a los admins cuando se detecta escalación."""
+        try:
+            admin_ids = clinic.get("admin_chat_ids", [])
+            if isinstance(admin_ids, str):
+                import json
+                admin_ids = json.loads(admin_ids) if admin_ids else []
+            clinic_name = clinic.get("name", "la clínica")
+            msg = (
+                f"ESCALACIÓN detectada en {clinic_name}\n"
+                f"Paciente: {chat_id}\n"
+                f"Mensaje: {text[:150]}"
+            )
+            log.warning("[escalacion] %s", msg)
+            # El envío real lo hace conny.py con _send_message
+            # Aquí solo dejamos el log — el handler de escalación ya respondió al paciente
+        except Exception as e:
+            log.warning("[orchestrator] error en notify_escalation: %s", e)

package/v7/postprocess.py

@@ -0,0 +1,127 @@
+"""
+Conny V7.0 — Postprocessor Determinístico
+=============================================
+Humaniza la respuesta cruda del LLM sin llamar a ningún otro modelo.
+Garantías: sin em dash, sin punto final, sin frases relleno, sin emojis.
+"""
+
+from __future__ import annotations
+import re
+import unicodedata
+from typing import List
+
+
+# ── Frases relleno que el LLM colea aunque el prompt las prohíba ──────────────
+_STRIP_PHRASES = [
+    "con mucho gusto", "encantada de conocerte", "encantado de conocerte",
+    "es un placer", "fue un placer", "en qué más le puedo servir",
+    "en qué más puedo ayudarte", "estoy aquí para ayudarte",
+    "por supuesto,", "definitivamente,", "absolutamente,",
+    "claro que sí,", "claro que si,", "con gusto te ayudo",
+    "con gusto te cuento", "me alegra que preguntes",
+    "perfecto, entiendo,", "te cuento que", "lo que pasa es que",
+    "en ese sentido,", "de hecho,", "con todo gusto",
+]
+
+# ── Emojis ────────────────────────────────────────────────────────────────────
+_EMOJI_RE = re.compile(
+    "["
+    "\U0001F600-\U0001F64F"
+    "\U0001F300-\U0001F5FF"
+    "\U0001F680-\U0001F6FF"
+    "\U0001F1E0-\U0001F1FF"
+    "\U00002500-\U00002BEF"
+    "\U00002702-\U000027B0"
+    "\U0001F900-\U0001F9FF"
+    "\U0001FA00-\U0001FAFF"
+    "\u2600-\u26FF"
+    "\u2700-\u27BF"
+    "]+",
+    flags=re.UNICODE,
+)
+
+
+def postprocess(text: str, is_premium: bool = False) -> str:
+    """
+    Limpia y humaniza la respuesta. Sin LLM. Determinístico.
+    is_premium=True → conserva mayúscula inicial.
+    """
+    if not text:
+        return text
+
+    # 1. Em dash → espacio (siempre, sin excepción)
+    text = re.sub(r"\s*—\s*", " ", text)
+
+    # 2. Emojis
+    text = _EMOJI_RE.sub("", text)
+
+    # 3. ¿¡
+    text = text.replace("¿", "").replace("¡", "")
+
+    # 4. Espacios
+    text = re.sub(r"\s+", " ", text)
+    text = re.sub(r"\s*\|\|\|\s*", " ||| ", text)
+
+    # 5. Por burbuja
+    if "|||" in text:
+        bubbles = [_per_bubble(b, is_premium) for b in text.split("|||")]
+        text = " ||| ".join(b for b in bubbles if b.strip())
+    else:
+        text = _per_bubble(text, is_premium)
+
+    # 6. Frases relleno (después de por-burbuja para mayor coverage)
+    for phrase in _STRIP_PHRASES:
+        pattern = re.compile(re.escape(phrase), re.IGNORECASE)
+        text = pattern.sub("", text)
+
+    # 7. Limpiar residuos
+    text = re.sub(r"\s+", " ", text).strip()
+    text = re.sub(r"^\s*,\s*", "", text)
+
+    return text
+
+
+def _per_bubble(s: str, is_premium: bool) -> str:
+    s = s.strip()
+    if not s:
+        return s
+
+    # Quitar punto final
+    if s.endswith(".") and not s.endswith("..."):
+        s = s[:-1].strip()
+
+    # Quitar guión al inicio/fin (residuo post em-dash)
+    s = re.sub(r"^\s*-\s+", "", s)
+    s = re.sub(r"\s+-\s*$", "", s)
+    s = s.strip()
+
+    # Truncar si supera 90 chars (burbuja demasiado larga)
+    if len(s) > 90:
+        cut = max(s.rfind(". ", 0, 90), s.rfind(", ", 0, 90), s.rfind(" y ", 0, 90))
+        if cut > 40:
+            s = s[:cut].strip().rstrip(",").rstrip(".")
+
+    # Mayúscula inicial solo para premium, minúscula para el resto
+    if s:
+        if is_premium:
+            # Premium: siempre mayúscula
+            s = s[0].upper() + s[1:]
+        else:
+            # General: minúscula excepto siglas o nombres propios obvios
+            first_word = s.split()[0] if s.split() else ""
+            is_acronym = (len(first_word) <= 5
+                          and first_word == first_word.upper()
+                          and len(first_word) > 1)
+            if not is_acronym:
+                s = s[0].lower() + s[1:]
+
+    return s
+
+
+def split_bubbles(text: str, max_bubbles: int = 3) -> List[str]:
+    """Divide el texto en burbujas y limita la cantidad."""
+    if "|||" in text:
+        parts = [b.strip() for b in text.split("|||") if b.strip()]
+    else:
+        parts = [text.strip()] if text.strip() else []
+    return parts[:max_bubbles]

package/v7/router.py

@@ -0,0 +1,239 @@
+"""
+Conny V7.0 — Router de Intención
+===================================
+Clasifica el mensaje entrante al agente correcto en 3 capas:
+  Capa 1: señales exactas (regex)     → 5-15ms, costo 0
+  Capa 2: señales semánticas (score)  → 15-30ms, costo 0
+  Capa 3: LLM fallback                → 400ms, solo si confianza < THRESHOLD
+
+Nunca llama al LLM para los casos claros (>85% de los mensajes reales).
+"""
+
+from __future__ import annotations
+import re
+import time
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+from enum import Enum
+
+log = logging.getLogger(__name__)
+
+CONFIDENCE_THRESHOLD = 0.65  # bajo esto → LLM fallback
+
+
+# ── Agentes disponibles ───────────────────────────────────────────────────────
+
+class AgentID(str, Enum):
+    CAPTACION    = "captacion"
+    OBJECIONES   = "objeciones"
+    AGENDA       = "agenda"
+    SEGUIMIENTO  = "seguimiento"
+    CONOCIMIENTO = "conocimiento"
+    ESCALACION   = "escalacion"
+    ADMIN        = "admin"
+    FALLBACK     = "fallback"   # generator clásico si ningún agente matchea
+
+
+# ── Resultado del router ──────────────────────────────────────────────────────
+
+@dataclass
+class RouterResult:
+    agent_id:    AgentID
+    confidence:  float
+    signals:     List[str]          # qué señales dispararon la decisión
+    context_keys: List[str]         # qué campos de memoria necesita el agente
+    latency_ms:  float = 0.0
+
+    @property
+    def is_confident(self) -> bool:
+        return self.confidence >= CONFIDENCE_THRESHOLD
+
+
+# ── Definición de señales por agente ─────────────────────────────────────────
+
+# Cada señal tiene: patrón regex, peso (0-1), contexto_mínimo
+_SIGNALS: Dict[AgentID, List[Tuple[str, float]]] = {
+
+    AgentID.ESCALACION: [
+        # Alta prioridad — se evalúa PRIMERO
+        (r"\b(emergencia|urgente|me duele mucho|reacción|alergia|complicación|demanda|abogado|denunciar)\b", 0.95),
+        (r"\b(hablar con (alguien|una persona|el dueño|el doctor)|quiero quejarme)\b", 0.90),
+        (r"\b(me quedó mal|quedé horrible|daño|perjuicio)\b", 0.85),
+    ],
+
+    AgentID.OBJECIONES: [
+        (r"\b(caro|costoso|muy caro|no tengo plata|presupuesto|precio alto)\b", 0.90),
+        (r"\b(pensarlo|lo pienso|déjame pensar|no sé si|lo consulto|mi (pareja|esposo|esposa|mamá))\b", 0.88),
+        (r"\b(miedo|da miedo|me asusta|quede (rara|exagerada|tiesa|mal)|se note|natural)\b", 0.90),
+        (r"\b(ya fui|fui a otro|otra clínica|otro lugar|en otro lado)\b", 0.88),
+        (r"\b(no funciona|no sirve|pura carreta|no creo|esceptic|dudas?)\b", 0.85),
+        (r"\b(no tengo tiempo|muy ocupad|trabajo mucho|no puedo ir)\b", 0.82),
+        (r"\b(vergüenza|pena|me da pena|qué dirán)\b", 0.85),
+        (r"\b(bogotá|exterior|fuera del país|afuera)\b", 0.75),
+    ],
+
+    AgentID.AGENDA: [
+        (r"\b(agendar|agenda|cita|turno|hora|reservar|apartar)\b", 0.92),
+        (r"\b(cuándo (tienen|puedo|hay|están|podría))\b", 0.88),
+        (r"\b(disponibilidad|disponible|libre|espacio)\b", 0.85),
+        (r"\b(lunes|martes|miércoles|miercoles|jueves|viernes|sábado|sabado|domingo)\b", 0.75),
+        (r"\b(mañana|esta semana|próxima semana|este mes)\b", 0.70),
+        (r"\b(puedo ir|quiero ir|ir a la clínica|ir a consulta)\b", 0.80),
+        (r"\b(valoración|valoracion|consulta)\b", 0.72),
+    ],
+
+    AgentID.CONOCIMIENTO: [
+        (r"\b(qué es|que es|cómo funciona|como funciona|qué hace|explica)\b", 0.88),
+        (r"\b(cuánto dura|tiempo de recuperación|recuperación|efectos|riesgos|contraindicaciones)\b", 0.90),
+        (r"\b(diferencia entre|diferencia del|cuál es mejor|cuál recomiendas)\b", 0.85),
+        (r"\b(botox|relleno|rellenos|láser|laser|hilos|mesoterapia|peeling|facelift|bichectomía|rinoplastia|liposucción)\b", 0.72),
+        (r"\b(cuántas sesiones|cuánto tiempo|cuándo veo resultados|resultados)\b", 0.80),
+        (r"\b(antes y después|fotos de resultados|casos)\b", 0.78),
+    ],
+
+    AgentID.CAPTACION: [
+        (r"\b(hola|buenas|buenos días|buenos dias|buenas tardes|buenas noches)\b", 0.70),
+        (r"\b(información|informacion|info|quiero saber|me interesa|quisiera)\b", 0.75),
+        (r"\b(primera vez|nunca he ido|primer vez)\b", 0.85),
+        (r"\b(me recomendaron|me dijeron|escuché de|leí sobre)\b", 0.78),
+        (r"\b(qué servicios|qué ofrecen|qué hacen|cuáles (son|tienen))\b", 0.80),
+        (r"^(hola|buenas|hi|hey|buen día)[.!?\s]*$", 0.85),  # solo saludo
+    ],
+
+    AgentID.SEGUIMIENTO: [
+        # Mayormente activado por cron, pero también por texto
+        (r"\b(cómo quedé|cómo me veo|cómo salió|resultados?\s*de\s*mi)\b", 0.88),
+        (r"\b(ya me lo hice|ya fui|ya vine|me lo hicieron)\b", 0.82),
+        (r"\b(seguimiento|control|revisión|revision)\b", 0.85),
+    ],
+}
+
+# Contexto que necesita cada agente de la memoria
+_CONTEXT_KEYS: Dict[AgentID, List[str]] = {
+    AgentID.CAPTACION:    ["patient_name", "visits", "funnel_state", "clinic_tone"],
+    AgentID.OBJECIONES:   ["patient_name", "objeciones_pasadas", "funnel_state", "clinic_tone", "servicios_relevantes"],
+    AgentID.AGENDA:       ["patient_name", "funnel_state", "ultima_cita", "calendar_available"],
+    AgentID.CONOCIMIENTO: ["servicios_clinica", "precios", "clinic_kb_excerpt"],
+    AgentID.SEGUIMIENTO:  ["patient_name", "ultima_cita", "procedimiento_realizado"],
+    AgentID.ESCALACION:   ["patient_name", "admin_chat_ids", "clinic_phone"],
+    AgentID.FALLBACK:     ["full_context"],  # fallback recibe todo
+}
+
+
+# ── Router principal ──────────────────────────────────────────────────────────
+
+class IntentRouter:
+    """
+    Router de tres capas.
+    Se instancia una vez al arranque y se reutiliza para todos los mensajes.
+    """
+
+    def __init__(self):
+        # Precompilar todos los patrones
+        self._compiled: Dict[AgentID, List[Tuple[re.Pattern, float]]] = {}
+        for agent_id, signals in _SIGNALS.items():
+            self._compiled[agent_id] = [
+                (re.compile(pat, re.IGNORECASE | re.UNICODE), weight)
+                for pat, weight in signals
+            ]
+        log.info("[router] IntentRouter listo — %d agentes registrados", len(self._compiled))
+
+    def route(
+        self,
+        text: str,
+        funnel_state: str = "primer_contacto",
+        history_length: int = 0,
+        is_cron: bool = False,
+        cron_type: Optional[str] = None,
+    ) -> RouterResult:
+        """
+        Clasifica el mensaje y devuelve el agente más apropiado.
+        Esta función NUNCA llama al LLM.
+        """
+        t0 = time.perf_counter()
+
+        # Cron triggers van directamente a seguimiento
+        if is_cron:
+            return RouterResult(
+                agent_id=AgentID.SEGUIMIENTO,
+                confidence=1.0,
+                signals=[f"cron:{cron_type}"],
+                context_keys=_CONTEXT_KEYS[AgentID.SEGUIMIENTO],
+                latency_ms=(time.perf_counter() - t0) * 1000,
+            )
+
+        # Capa 1: scoring por señales regex
+        scores: Dict[AgentID, Tuple[float, List[str]]] = {}
+        for agent_id, patterns in self._compiled.items():
+            hits = []
+            total_weight = 0.0
+            for pattern, weight in patterns:
+                if pattern.search(text):
+                    hits.append(pattern.pattern[:40])
+                    total_weight = max(total_weight, weight)
+            if hits:
+                scores[agent_id] = (total_weight, hits)
+
+        # Capa 2: ajuste por estado del funnel
+        scores = self._adjust_by_funnel(scores, funnel_state, history_length)
+
+        # Elegir ganador
+        if scores:
+            best_agent = max(scores, key=lambda a: scores[a][0])
+            best_score, best_signals = scores[best_agent]
+        else:
+            best_agent  = AgentID.CAPTACION
+            best_score  = 0.40
+            best_signals = ["sin_señales_explícitas"]
+
+        latency = (time.perf_counter() - t0) * 1000
+        log.debug(
+            "[router] %s confianza=%.2f señales=%s latencia=%.1fms",
+            best_agent.value, best_score, best_signals[:2], latency
+        )
+
+        return RouterResult(
+            agent_id=best_agent,
+            confidence=best_score,
+            signals=best_signals,
+            context_keys=_CONTEXT_KEYS.get(best_agent, _CONTEXT_KEYS[AgentID.FALLBACK]),
+            latency_ms=latency,
+        )
+
+    def _adjust_by_funnel(
+        self,
+        scores: Dict[AgentID, Tuple[float, List[str]]],
+        funnel_state: str,
+        history_length: int,
+    ) -> Dict[AgentID, Tuple[float, List[str]]]:
+        """
+        Ajusta los scores según el contexto del funnel.
+        El funnel no sobreescribe señales fuertes — solo desempata.
+        """
+        adjusted = dict(scores)
+
+        # Si es primer contacto y no hay señales claras → captacion gana
+        if funnel_state == "primer_contacto" and history_length == 0:
+            if AgentID.CAPTACION not in adjusted:
+                adjusted[AgentID.CAPTACION] = (0.65, ["funnel:primer_contacto"])
+            else:
+                sc, sig = adjusted[AgentID.CAPTACION]
+                adjusted[AgentID.CAPTACION] = (min(sc + 0.10, 1.0), sig + ["funnel:boost_primer_contacto"])
+
+        # Si tiene intención confirmada y hay señal de agenda → boost agenda
+        if funnel_state == "con_intencion" and AgentID.AGENDA in adjusted:
+            sc, sig = adjusted[AgentID.AGENDA]
+            adjusted[AgentID.AGENDA] = (min(sc + 0.12, 1.0), sig + ["funnel:boost_con_intencion"])
+
+        # Escalacion siempre tiene prioridad — no se reduce
+        if AgentID.ESCALACION in adjusted:
+            sc, sig = adjusted[AgentID.ESCALACION]
+            adjusted[AgentID.ESCALACION] = (max(sc, 0.92), sig)
+
+        return adjusted
+
+
+# ── Instancia global (singleton) ─────────────────────────────────────────────
+# Se importa desde conny.py:  from router import router
+router = IntentRouter()

package/verify_conversation_impl.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Verificar que todas las funciones de conversación están presentes."""
+import re
+
+with open('conny-omni.py', 'r') as f:
+    content = f.read()
+
+checks = {
+    'get_recent_conversations': (r'async def get_recent_conversations\(', 'Obtener conversaciones recientes'),
+    'get_active_conversations': (r'async def get_active_conversations\(', 'Obtener conversaciones activas'),
+    'format_active_conversations': (r'def format_active_conversations\(', 'Formatear lista de conversaciones'),
+    'format_conversation_detail': (r'def format_conversation_detail\(', 'Formatear detalle de conversación'),
+    '/conversations handler': (r"text\.lower\(\)\.startswith\(\"/conversations\"\)", 'Manejador /conversations'),
+    '/enter handler': (r'text\.startswith\(\"/enter ', 'Manejador /enter'),
+    '/list handler': (r'text\.lower\(\) == \"/list\"', 'Manejador /list'),
+    'Natural intent detection': (r'conversation_keywords = \[', 'Detección de intención natural'),
+    'muéstrame/dame detection': (r"any\(kw in text_lower for kw in \[\"muéstrame\",", 'Detección muéstrame/dame'),
+    'quién está detection': (r"any\(kw in text_lower for kw in \[\"quién\", \"quien\"", 'Detección quién está'),
+    'System prompt update': (r'"También eres GESTORA DE CONVERSACIONES"', 'System prompt actualizado'),
+    'Help text update': (r"\*Gestión de Conversaciones:\*", 'Help text actualizado'),
+}
+
+print("=" * 70)
+print("✅ VERIFICACIÓN: Conny Omni v2.1 - Conversation Features")
+print("=" * 70)
+print()
+
+all_ok = True
+for name, (pattern, desc) in checks.items():
+    if re.search(pattern, content, re.MULTILINE):
+        print(f"✅ {name:30} - {desc}")
+    else:
+        print(f"❌ {name:30} - {desc}")
+        all_ok = False
+
+print()
+print("=" * 70)
+if all_ok:
+    print("✅ TODAS LAS VERIFICACIONES PASARON")
+    print("🎉 Omni v2.1 está LISTO para producción")
+else:
+    print("❌ ALGUNAS VERIFICACIONES FALLARON")
+    
+print("=" * 70)
+
+# Contar líneas de código nuevo
+conv_section = content[content.find('async def get_recent_conversations'):content.find('# ══════════════════════════════════════════════════════════════════════════════\n# NOTIFICACIONES')]
+print(f"\nLíneas de código para conversaciones: ~{len(conv_section.splitlines())} líneas")