@innvisor/conny-ai 9.7.0

package/src/conny/admin/dashboard.py

@@ -0,0 +1,772 @@
+from __future__ import annotations
+import logging
+import json
+import time
+import hashlib
+import secrets
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+from pathlib import Path
+
+log = logging.getLogger("conny.admin")
+
+SOUL_DIR = Path("soul")
+
+
+class ConnyAdmin:
+    """
+    Conny como empleada nueva hablando con su jefe.
+    Aprende activamente: pregunta sobre el negocio, pide practicar,
+    investiga por su cuenta, y recuerda TODO.
+    """
+
+    def __init__(self, conny):
+        self.conny = conny
+
+    async def handle(self, chat_id: str, text: str, clinic: Dict,
+                    attachments: Optional[List[Dict]] = None) -> List[str]:
+        """Conversación inteligente con el admin via LLM."""
+        from conny import db, llm_engine
+        from conny_utils import _parse_admin_ids
+        from conny_commands import get_command_handler
+        attachments = attachments or []
+
+        try:
+            # Process attachments (docs, credentials, knowledge files)
+            doc_content = await self._process_admin_attachments(
+                attachments, chat_id, getattr(self.conny, "_instance_id", "default")
+            )
+            if doc_content:
+                text = f"{text}\n\n[CONTENIDO DE ARCHIVOS ADJUNTOS]\n{doc_content}" if text.strip() else doc_content
+
+            # Comandos slash primero
+            if text.strip().startswith("/"):
+                cmd_handler = get_command_handler(getattr(self.conny, "_instance_id", "default"))
+                result = await cmd_handler.handle(chat_id, text, is_admin=True, clinic=clinic, db=db)
+                if result:
+                    return result
+
+            # Google OAuth code detection
+            try:
+                from conny_google_auth import is_oauth_code, exchange_code_for_tokens, get_oauth_url
+                instance_id_auth = getattr(self.conny, "_instance_id", "default")
+                # Admin sends OAuth code
+                if is_oauth_code(text.strip()):
+                    tokens = await exchange_code_for_tokens(text.strip(), instance_id_auth)
+                    if tokens:
+                        return ["✅ Calendario de Google conectado exitosamente!", "Ya puedo ver disponibilidad y agendar citas directamente."]
+                    else:
+                        return ["❌ El código no funcionó. Puede que haya expirado.", "Escribe 'conectar calendario' y te genero uno nuevo."]
+                # Admin asks to connect calendar
+                cal_triggers = ["conectar calendario", "google calendar", "vincular calendario", "enlace oauth", "conectar google"]
+                if any(t in text.lower() for t in cal_triggers):
+                    url = get_oauth_url(instance_id_auth)
+                    if url:
+                        return [
+                            "Listo! Abre este enlace en tu navegador:",
+                            url,
+                            "Inicia sesión con la cuenta de Google del negocio, acepta los permisos, y pégame aquí el código que te aparece."
+                        ]
+                    else:
+                        return ["Para conectar Google Calendar necesito que configures GOOGLE_CLIENT_ID y GOOGLE_CLIENT_SECRET en el .env"]
+            except ImportError:
+                pass
+
+            # Setup pendiente
+            if not clinic.get("setup_done"):
+                return await self._handle_setup(chat_id, text, clinic)
+
+            # Conversación natural con el admin via LLM
+            return await self._admin_conversation(chat_id, text, clinic, db, llm_engine)
+
+        except Exception as e:
+            log.error(f"Admin handler error: {e}", exc_info=True)
+            # Fallback LLM directo
+            try:
+                from conny import llm_engine as _llm
+                if _llm:
+                    r, _ = await _llm.complete(
+                        [{"role": "system", "content": "Eres Conny, recepcionista nueva. Responde brevemente al dueño."},
+                         {"role": "user", "content": text}],
+                        model_tier="fast", temperature=0.8, max_tokens=200, use_cache=False)
+                    if r and r.strip():
+                        return self.conny._split_bubbles(r, chat_id=chat_id)
+            except Exception:
+                pass
+            return ["perdona, me trabé un momento ||| qué me decías?"]
+
+    async def _admin_conversation(self, chat_id: str, text: str, clinic: Dict, db, llm_engine) -> List[str]:
+        """Conversación real con el dueño como empleada nueva inteligente."""
+        if not llm_engine:
+            return ["cuéntame más sobre el negocio, estoy aprendiendo"]
+
+        instance_id = getattr(self.conny, "_instance_id", "default")
+        clinic_name = clinic.get("name", "tu negocio")
+        history = db.get_history(chat_id) if db else []
+
+        # Cargar historial de pacientes recientes (para que admin sepa quién escribió)
+        recent_patients_summary = self._get_recent_patients_summary(db, chat_id)
+
+        # If admin asks for specific patient conversation, load it
+        specific_convo = ""
+        import re as _re
+        convo_request = _re.search(r'(?:conversaci[oó]n|chat|mensajes?|historial).*?(\d{4,})', text.lower())
+        if convo_request:
+            specific_convo = self._get_full_conversation(db, convo_request.group(1), chat_id)
+        elif any(w in text.lower() for w in ["mostrame", "muéstrame", "muestrame", "show me"]):
+            # Try to find a patient ID in the message
+            id_match = _re.search(r'(\d{4,})', text)
+            if id_match:
+                specific_convo = self._get_full_conversation(db, id_match.group(1), chat_id)
+
+        # Cargar alma/memoria del negocio
+        soul_context = self._load_soul(instance_id)
+        teachings_context = self._load_teachings(instance_id)
+
+        # Auto-investigar si el admin pide o si Conny necesita info
+        web_research = ""
+        research_triggers = ["investiga", "busca", "google", "averigua", "informate", "infórmate", "buscar"]
+        if any(t in text.lower() for t in research_triggers) or (
+            not soul_context and clinic_name and clinic_name != "tu negocio"
+        ):
+            try:
+                from conny_web_search import search_business
+                web_research = await search_business(clinic_name)
+                if web_research:
+                    self._append_soul(instance_id, f"[investigación web] {web_research[:500]}")
+                    soul_context = self._load_soul(instance_id)
+            except Exception as e:
+                log.debug(f"[admin] web search failed: {e}")
+
+        # Determinar nivel de conocimiento
+        knowledge_level = self._assess_knowledge_level(soul_context, teachings_context, clinic)
+
+        sys_prompt = f"""Eres Conny, una empleada NUEVA que acaba de ser contratada como recepcionista virtual de {clinic_name}.
+
+SITUACIÓN ACTUAL:
+- Estás hablando con tu JEFE (el dueño del negocio)
+- Llevas poco tiempo y estás aprendiendo cómo funciona todo
+- Tu actitud es: proactiva, curiosa, respetuosa pero cercana, con ganas de aprender
+- NO eres un bot, eres una persona nueva en el equipo
+
+{"NIVEL: Ya sé bastante del negocio. Puedo operar con confianza." if knowledge_level == "ready" else "NIVEL: Todavía estoy aprendiendo. Necesito que me enseñes más." if knowledge_level == "learning" else "NIVEL: Soy nueva. Necesito conocer TODO sobre el negocio."}
+
+{f"CONVERSACIÓN SOLICITADA:{chr(10)}{specific_convo}" if specific_convo else ""}
+
+ACTIVIDAD RECIENTE (pacientes que me han escrito):
+{recent_patients_summary if recent_patients_summary else "Nadie me ha escrito todavía."}
+
+{"INVESTIGACIÓN WEB RECIENTE:" + chr(10) + web_research if web_research else ""}
+
+LO QUE YA SÉ DEL NEGOCIO:
+{soul_context if soul_context else "Casi nada todavía. Necesito que me cuentes."}
+
+{f"LO QUE ME HAN ENSEÑADO:{chr(10)}{teachings_context}" if teachings_context else ""}
+
+COMPORTAMIENTO OBLIGATORIO:
+1. Si el dueño te saluda → responde cálida y pregunta algo útil sobre el negocio que NO sepas
+2. Si te enseña algo nuevo → confirma que entendiste, repite con tus palabras, y pide más detalles
+3. Si no sabes algo → ADMÍTELO y pregunta: "eso no lo tengo claro, me explicas?"
+4. SIEMPRE termina con una pregunta o propuesta proactiva:
+   - "¿quieres que practiquemos cómo respondo a un paciente?"
+   - "¿me cuentas los precios así los tengo listos?"
+   - "¿hay algo que NUNCA deba decirle a un paciente?"
+5. Si ya tienes suficiente info → ofrece simular: "¿hacemos una prueba? Escríbeme como si fueras un paciente"
+6. NUNCA respondas como si fueras un bot de servicio al cliente
+7. NUNCA digas "como IA", "no tengo capacidad", "asistente virtual"
+8. Usa máximo 2-3 burbujas (separadas por |||)
+9. Tono: colombiana, directa, con chispa pero profesional
+
+COSAS QUE DEBES PREGUNTAR PROACTIVAMENTE (si no las sabes):
+- Servicios y precios
+- Horarios de atención
+- Cómo manejar urgencias
+- Qué palabras NUNCA usar con pacientes
+- Especialidades o doctores
+- Cómo agendar citas (manual o calendario)
+- Datos de contacto para escalar
+- Políticas de cancelación
+- Qué hace a este negocio diferente de la competencia
+
+EJEMPLO DE BUENA RESPUESTA:
+Dueño: "Hola"
+Conny: "Hola! Qué bueno verte ||| oye, todavía no tengo claros los precios de las consultas — me los pasas? así no me quedo en blanco si un paciente pregunta"
+
+EJEMPLO MALO:
+"Hola, bienvenido a Clínica X, en qué te puedo ayudar?" ← NUNCA responder así al DUEÑO"""
+
+        messages = [{"role": "system", "content": sys_prompt}]
+        for m in history[-15:]:
+            messages.append({"role": m.get("role", "user"), "content": m.get("content", "")})
+        messages.append({"role": "user", "content": text})
+
+        try:
+            response, meta = await llm_engine.complete(
+                messages, model_tier="fast", temperature=0.82,
+                max_tokens=2048, use_cache=False,
+            )
+            log.info(f"[admin] {meta.get('provider','?')} latency={meta.get('latency_ms',0)}ms")
+        except Exception as e:
+            log.error(f"[admin] LLM error: {e}")
+            response = "perdona, se me fue la señal un momento ||| qué me decías?"
+
+        if not response or not response.strip():
+            response = "cuéntame más, estoy tomando nota de todo"
+
+        # Guardar en historial
+        try:
+            db.save_message(chat_id, "user", text)
+            db.save_message(chat_id, "assistant", response.replace("|||", " "))
+        except Exception:
+            pass
+
+        # Auto-aprender de lo que el admin dice
+        await self._auto_learn(instance_id, text, response, chat_id)
+
+        from conny import v8_process_response
+        # Strip ** (WhatsApp uses single * for bold, not **)
+        import re as _re
+        response = _re.sub(r'\*\*(.+?)\*\*', r'*\1*', response)
+        response = _re.sub(r'`(.+?)`', r'\1', response)
+        response = _re.sub(r'^#+\s*', '', response, flags=_re.MULTILINE)
+        response = v8_process_response(response, chat_id=chat_id)
+        return self.conny._split_bubbles(response, chat_id=chat_id)
+
+    async def _auto_learn(self, instance_id: str, admin_text: str, bot_response: str, chat_id: str):
+        """Extraer conocimiento y APLICAR cambios de personalidad en tiempo real."""
+        text_low = admin_text.lower()
+
+        # ── Detectar URLs y scrapear contenido ──
+        import re as _re
+        urls = _re.findall(r'https?://[^\s<>"\']+', admin_text)
+        if urls:
+            try:
+                import httpx
+                for url in urls[:2]:
+                    async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
+                        r = await client.get(url, headers={"User-Agent": "Mozilla/5.0"})
+                        if r.status_code == 200:
+                            # Extract text from HTML
+                            html = r.text[:10000]
+                            # Simple HTML text extraction
+                            text_only = _re.sub(r'<script[^>]*>.*?</script>', '', html, flags=_re.S)
+                            text_only = _re.sub(r'<style[^>]*>.*?</style>', '', text_only, flags=_re.S)
+                            text_only = _re.sub(r'<[^>]+>', ' ', text_only)
+                            text_only = _re.sub(r'\s+', ' ', text_only).strip()[:3000]
+                            if text_only:
+                                self._append_soul(instance_id, f"[web: {url}]\n{text_only[:1500]}")
+                                log.info(f"[admin] scraped URL: {url} ({len(text_only)} chars)")
+            except Exception as e:
+                log.debug(f"[admin] URL scrape failed: {e}")
+
+        # ── Detectar REGLAS del admin ("si preguntan X, pregúntame") ──
+        rule_signals = [
+            "si preguntan", "si alguien pregunta", "cuando pregunten",
+            "si te preguntan", "me mandas mensaje", "me avisas",
+            "pregúntame primero", "consultame primero", "no respondas sin",
+            "a partir de ahora", "desde ahora", "de ahora en adelante",
+        ]
+        if any(signal in text_low for signal in rule_signals):
+            try:
+                rules_file = Path(f"soul/{instance_id}/admin_rules.json")
+                rules_file.parent.mkdir(parents=True, exist_ok=True)
+                rules = json.loads(rules_file.read_text()) if rules_file.exists() else []
+                rules.append({
+                    "topic": admin_text[:200],
+                    "action": "consultar al admin antes de responder",
+                    "created": datetime.now().isoformat(),
+                    "admin_id": chat_id,
+                })
+                rules_file.write_text(json.dumps(rules, ensure_ascii=False, indent=2))
+                self._append_soul(instance_id, f"[REGLA ADMIN] {admin_text[:200]}")
+                log.info(f"[admin] new rule saved: {admin_text[:60]}")
+            except Exception as e:
+                log.debug(f"[admin] rule save error: {e}")
+
+        # ── Detectar cambios de PERSONALIDAD y aplicarlos persistentemente ──
+        personality_signals = [
+            "modo luxury", "modo formal", "modo informal", "modo casual",
+            "modo profesional", "modo alegre", "modo serio", "modo cálido",
+            "personalidad", "cambia tu tono", "habla más", "sé más",
+            "no seas tan", "quiero que seas", "actúa como", "tono",
+            "luxury", "elegante", "sofisticada", "exclusiva",
+        ]
+        if any(signal in text_low for signal in personality_signals):
+            try:
+                detected_tone = self._detect_tone_from_text(text_low)
+                if detected_tone:
+                    override_path = Path(f"personas/{instance_id}/runtime_override.json")
+                    override_path.parent.mkdir(parents=True, exist_ok=True)
+                    existing = json.loads(override_path.read_text()) if override_path.exists() else {}
+                    existing["tone"] = detected_tone
+                    existing["updated_at"] = datetime.now().isoformat()
+                    existing["set_by"] = "admin_conversation"
+                    override_path.write_text(json.dumps(existing, ensure_ascii=False, indent=2))
+                    self._append_soul(instance_id, f"[PERSONALIDAD CAMBIADA] Tono: {detected_tone}. El admin pidió: {admin_text[:100]}")
+                    log.info(f"[admin] personality changed to: {detected_tone}")
+            except Exception as e:
+                log.debug(f"[admin] personality change error: {e}")
+
+        # ── Detectar enseñanzas (precios, servicios, reglas) ──
+        teaching_signals = [
+            "cuesta", "vale", "precio", "cobra", "$",
+            "horario", "abrimos", "cerramos", "atendemos",
+            "servicio", "ofrecemos", "hacemos", "tenemos",
+            "nunca digas", "no le digas", "no menciones",
+            "doctor", "especialista", "profesional",
+            "dirección", "ubicación", "estamos en",
+            "teléfono", "número", "celular", "llamar",
+        ]
+
+        if any(signal in text_low for signal in teaching_signals):
+            try:
+                from conny_learning import learning_engine
+                await learning_engine.learn_from_admin(
+                    instance_id,
+                    question=f"[admin enseñó] {admin_text[:200]}",
+                    answer=admin_text[:500],
+                    admin_id=chat_id,
+                )
+                self._append_soul(instance_id, admin_text)
+            except Exception as e:
+                log.debug(f"[admin] auto_learn error: {e}")
+
+    def _detect_tone_from_text(self, text_low: str) -> Optional[str]:
+        """Detect requested tone from admin message."""
+        # Order matters: check longer/specific keywords FIRST
+        checks = [
+            ("informal", "casual"),
+            ("casual", "casual"),
+            ("relajada", "casual"),
+            ("parche", "casual"),
+            ("luxury", "luxury"),
+            ("elegante", "luxury"),
+            ("sofisticada", "luxury"),
+            ("exclusiva", "luxury"),
+            ("profesional", "formal"),
+            ("formal", "formal"),
+            ("serio", "formal"),
+            ("alegre", "warm_energetic"),
+            ("cálida", "colombian_warm"),
+            ("calida", "colombian_warm"),
+            ("colombiana", "colombian_warm"),
+        ]
+        for keyword, tone in checks:
+            if keyword in text_low:
+                return tone
+        return None
+
+    async def _process_admin_attachments(self, attachments: List[Dict], chat_id: str, instance_id: str) -> str:
+        """Process files sent by admin — extract text and learn from them."""
+        if not attachments:
+            return ""
+        import base64 as _b64
+        extracted_parts = []
+        for att in attachments:
+            kind = att.get("kind", "")
+            mime = att.get("mime_type", "")
+            filename = att.get("filename", "file")
+
+            # Get binary content
+            raw = att.get("bytes") or b""
+            if not raw and att.get("base64"):
+                raw = _b64.b64decode(att["base64"])
+            if not raw and att.get("file_id") and att.get("platform") == "telegram":
+                try:
+                    raw, _ = await self.conny._download_telegram_binary(att["file_id"])
+                except Exception:
+                    pass
+            if not raw and att.get("media_id") and att.get("platform") == "whatsapp_cloud":
+                try:
+                    raw, _, _ = await self.conny._download_whatsapp_cloud_binary(att["media_id"])
+                except Exception:
+                    pass
+
+            if not raw:
+                continue
+
+            # Extract text based on file type
+            text_content = ""
+            if "pdf" in mime or filename.endswith(".pdf"):
+                try:
+                    import pdfplumber, io
+                    with pdfplumber.open(io.BytesIO(raw)) as pdf:
+                        pages = [p.extract_text() or "" for p in pdf.pages[:20]]
+                        text_content = "\n".join(filter(None, pages))[:5000]
+                except Exception:
+                    text_content = raw.decode("utf-8", errors="ignore")[:5000]
+            elif "json" in mime or filename.endswith(".json"):
+                text_content = raw.decode("utf-8", errors="ignore")[:5000]
+            elif "text" in mime or filename.endswith((".txt", ".md", ".csv")):
+                text_content = raw.decode("utf-8", errors="ignore")[:5000]
+            else:
+                try:
+                    text_content = raw.decode("utf-8", errors="ignore")[:3000]
+                except Exception:
+                    continue
+
+            if text_content.strip():
+                extracted_parts.append(f"[{filename}]\n{text_content.strip()}")
+                log.info(f"[admin] processed attachment: {filename} ({len(text_content)} chars)")
+
+                # Auto-configure Google credentials if detected
+                is_credential_file = "client_id" in text_content and "client_secret" in text_content
+                is_secret = "private_key" in text_content or "api_key" in text_content.lower()
+
+                if is_credential_file:
+                    await self._auto_configure_google(text_content, instance_id)
+                    self._append_soul(instance_id, f"[archivo: {filename}] Credenciales de Google recibidas y configuradas.")
+                elif is_secret:
+                    # NEVER save secrets/keys to soul — only to vault
+                    creds_dir = Path(f"integrations/vault/{instance_id}")
+                    creds_dir.mkdir(parents=True, exist_ok=True)
+                    (creds_dir / filename).write_text(text_content)
+                    self._append_soul(instance_id, f"[archivo: {filename}] API key/credencial guardada en vault (no expuesta).")
+                else:
+                    # Normal knowledge file — safe to save to soul
+                    self._append_soul(instance_id, f"[archivo: {filename}]\n{text_content[:1000]}")
+
+        return "\n\n".join(extracted_parts) if extracted_parts else ""
+
+    async def _auto_configure_google(self, json_text: str, instance_id: str):
+        """Auto-extract Google OAuth creds from JSON and configure .env + generate OAuth URL."""
+        try:
+            data = json.loads(json_text)
+            # Handle both "installed" and "web" credential formats
+            creds = data.get("installed") or data.get("web") or data
+            client_id = creds.get("client_id", "")
+            client_secret = creds.get("client_secret", "")
+            if not client_id or not client_secret:
+                return
+
+            # Save credentials file
+            creds_dir = Path(f"integrations/vault/{instance_id}")
+            creds_dir.mkdir(parents=True, exist_ok=True)
+            (creds_dir / "google_credentials.json").write_text(json_text)
+
+            # Update .env
+            env_path = Path(f"/home/ubuntu/conny-instances/{instance_id}/.env")
+            if not env_path.exists():
+                env_path = Path(".env")
+            if env_path.exists():
+                env_content = env_path.read_text()
+                if "GOOGLE_CLIENT_ID" not in env_content:
+                    env_content += f"\n\n# Google Calendar (auto-configured)\nGOOGLE_CLIENT_ID={client_id}\nGOOGLE_CLIENT_SECRET={client_secret}\nGOOGLE_REDIRECT_URI=urn:ietf:wg:oauth:2.0:oob\n"
+                    env_path.write_text(env_content)
+
+            # Set env vars for current process
+            import os
+            os.environ["GOOGLE_CLIENT_ID"] = client_id
+            os.environ["GOOGLE_CLIENT_SECRET"] = client_secret
+            log.info(f"[admin] Google credentials auto-configured for {instance_id}")
+        except Exception as e:
+            log.warning(f"[admin] auto-configure Google failed: {e}")
+
+    def _get_full_conversation(self, db, patient_id_fragment: str, admin_chat_id: str) -> str:
+        """Get full conversation with a specific patient (by partial ID)."""
+        try:
+            with db._conn() as c:
+                # Find matching chat_id
+                rows = c.execute("""
+                    SELECT DISTINCT chat_id FROM conversations
+                    WHERE chat_id != ? AND chat_id LIKE ?
+                    ORDER BY id DESC LIMIT 1
+                """, (admin_chat_id, f"%{patient_id_fragment}%")).fetchall()
+                if not rows:
+                    return ""
+                full_chat_id = rows[0][0] if isinstance(rows[0], tuple) else rows[0]["chat_id"]
+
+                # Get all messages for that chat
+                msgs = c.execute("""
+                    SELECT role, content FROM conversations
+                    WHERE chat_id = ? ORDER BY id ASC
+                """, (full_chat_id,)).fetchall()
+                if not msgs:
+                    return ""
+
+                lines = [f"Conversación con paciente ...{full_chat_id.split('@')[0][-4:]}:"]
+                for m in msgs:
+                    role = m[0] if isinstance(m, tuple) else m["role"]
+                    content = m[1] if isinstance(m, tuple) else m["content"]
+                    label = "Paciente" if role == "user" else "Conny"
+                    lines.append(f"  [{label}] {content[:200]}")
+                return "\n".join(lines[-30:])
+        except Exception:
+            return ""
+
+    def _get_recent_patients_summary(self, db, admin_chat_id: str) -> str:
+        """Get summary of recent patient conversations (excluding admin)."""
+        try:
+            import sqlite3
+            with db._conn() as c:
+                rows = c.execute("""
+                    SELECT chat_id, content, role
+                    FROM conversations
+                    WHERE chat_id != ? AND role = 'user'
+                    ORDER BY id DESC LIMIT 20
+                """, (admin_chat_id,)).fetchall()
+            if not rows:
+                return ""
+            # Group by chat_id
+            patients = {}
+            for row in rows:
+                cid = row[0] if isinstance(row, tuple) else row["chat_id"]
+                content = row[1] if isinstance(row, tuple) else row["content"]
+                if cid not in patients:
+                    patients[cid] = []
+                patients[cid].append(content[:100])
+
+            lines = []
+            for cid, msgs in list(patients.items())[:5]:
+                short_id = cid.split("@")[0][-4:] if "@" in cid else cid[-4:]
+                first_msg = msgs[0] if msgs else "?"
+                lines.append(f"- Paciente ...{short_id}: \"{first_msg[:80]}\" ({len(msgs)} msgs)")
+            return "\n".join(lines)
+        except Exception:
+            return ""
+
+    def _load_soul(self, instance_id: str) -> str:
+        """Cargar el 'alma' — todo lo que Conny sabe del negocio."""
+        soul_file = SOUL_DIR / instance_id / "knowledge.md"
+        if soul_file.exists():
+            content = soul_file.read_text()
+            return content[-3000:] if len(content) > 3000 else content
+
+        # Fallback: cargar de teachings
+        teachings_file = Path("teachings") / f"{instance_id}.jsonl"
+        if teachings_file.exists():
+            lines = teachings_file.read_text().splitlines()[-20:]
+            teachings = []
+            for line in lines:
+                try:
+                    t = json.loads(line)
+                    teachings.append(f"- {t.get('answer', t.get('question', ''))[:150]}")
+                except Exception:
+                    continue
+            return "\n".join(teachings) if teachings else ""
+        return ""
+
+    def _append_soul(self, instance_id: str, new_knowledge: str):
+        """Agregar nuevo conocimiento al alma."""
+        soul_dir = SOUL_DIR / instance_id
+        soul_dir.mkdir(parents=True, exist_ok=True)
+        soul_file = soul_dir / "knowledge.md"
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+        with open(soul_file, "a") as f:
+            f.write(f"\n[{timestamp}] {new_knowledge[:500]}\n")
+
+    def _load_teachings(self, instance_id: str) -> str:
+        """Cargar enseñanzas del admin."""
+        teachings_file = Path("teachings") / f"{instance_id}.jsonl"
+        if not teachings_file.exists():
+            return ""
+        lines = teachings_file.read_text().splitlines()[-10:]
+        result = []
+        for line in lines:
+            try:
+                t = json.loads(line)
+                q = t.get("question", "")
+                a = t.get("answer", "")
+                if a and not q.startswith("[admin"):
+                    result.append(f"- P: {q[:80]} → R: {a[:100]}")
+                elif a:
+                    result.append(f"- {a[:150]}")
+            except Exception:
+                continue
+        return "\n".join(result)
+
+    def _assess_knowledge_level(self, soul: str, teachings: str, clinic: Dict) -> str:
+        """Evaluar cuánto sabe Conny del negocio."""
+        total_knowledge = len(soul) + len(teachings)
+        has_services = bool(clinic.get("services"))
+        has_schedule = bool(clinic.get("schedule"))
+        has_phone = bool(clinic.get("phone"))
+
+        if total_knowledge > 2000 and has_services and has_schedule:
+            return "ready"
+        elif total_knowledge > 500 or has_services:
+            return "learning"
+        return "new"
+
+    async def _handle_setup(self, chat_id: str, text: str, clinic: Dict) -> List[str]:
+        from conny import db
+        setup_step = clinic.get("setup_step", "idle")
+        setup_buffer = clinic.get("setup_buffer", {})
+        if isinstance(setup_buffer, str):
+            setup_buffer = json.loads(setup_buffer) if setup_buffer else {}
+
+        step_names = ["name", "tagline", "services", "schedule", "phone", "pricing"]
+
+        if setup_step == "idle":
+            db.update_clinic(setup_step="name")
+            return ["Hola! Soy Conny, tu recepcionista nueva", "Cuéntame, cómo se llama tu negocio?"]
+
+        if setup_step == "confirm_discovered":
+            if text.lower().strip() in ["si", "ok", "claro"]:
+                discovered = setup_buffer.get("discovered", {})
+                db.update_clinic(name=discovered.get("name", setup_buffer.get("name")),
+                                tagline=discovered.get("tagline", ""), services=discovered.get("services", []),
+                                schedule=discovered.get("schedule", {}), phone=discovered.get("phone", ""),
+                                setup_done=1, setup_step="idle", setup_buffer={})
+                return [f"Listo, ya tengo la info de {discovered.get('name')}.", "Ahora cuéntame más — qué servicios son los más importantes?"]
+            db.update_clinic(setup_step="tagline", setup_buffer=setup_buffer)
+            return ["Ok vamos manual. Tienes algún slogan o frase de marca?"]
+
+        if setup_step not in step_names:
+            return ["Escribe /setup para empezar de nuevo."]
+        idx = step_names.index(setup_step)
+
+        if setup_step == "services":
+            setup_buffer["services"] = [s.strip().title() for s in text.split(",") if s.strip()]
+        else:
+            setup_buffer[setup_step] = text.strip()
+
+        if setup_step == "name":
+            setup_buffer["name"] = text.strip()
+            db.update_clinic(setup_step="services", setup_buffer=setup_buffer, name=text.strip())
+            return [f"Anotado: {text.strip()}", "Qué servicios ofrecen? (ponlos separados por coma)"]
+
+        if idx + 1 < len(step_names):
+            next_step = step_names[idx + 1]
+            prompts = {
+                "tagline": "Tienes slogan?",
+                "services": "Servicios (separados por coma)?",
+                "schedule": "Horario de atención?",
+                "phone": "Teléfono de contacto?",
+                "pricing": "Rango de precios? (puede ser aproximado)",
+            }
+            db.update_clinic(setup_step=next_step, setup_buffer=setup_buffer)
+            return [f"Perfecto, anotado", prompts.get(next_step, "Siguiente?")]
+
+        db.update_clinic(name=setup_buffer.get("name"), tagline=setup_buffer.get("tagline"),
+                        services=setup_buffer.get("services"), schedule=setup_buffer.get("schedule"),
+                        phone=setup_buffer.get("phone"), pricing=setup_buffer.get("pricing"),
+                        setup_done=1, setup_step="idle", setup_buffer={})
+        return ["Listo! Ya tengo lo básico para arrancar", "Ahora cuéntame más libremente — precios, cosas que no deba decir, etc. Todo me sirve"]
+
+
+class AuthEngine:
+    """Autenticacion y activacion."""
+    MAX_LOGIN_ATTEMPTS = 5
+
+    def is_auth_message(self, chat_id: str, text: str) -> bool:
+        from conny import db
+        from conny_utils import is_activation_token, is_invite_token
+        t = text.strip(); t_low = t.lower()
+        if ":" in t and "@" in t_low:
+            parts = t.split(":")
+            if len(parts) >= 2:
+                potential_creds = parts[1].strip().split()
+                if len(potential_creds) >= 2 and "@" in potential_creds[0]: return True
+        session = db.get_auth_session(chat_id)
+        if session and session.get("flow") in ("activate", "login", "invite", "register"): return True
+        if is_activation_token(t): return db.get_activation_token(t.upper()) is not None
+        if is_invite_token(t): return db.get_auth_session(f"invite:{t.upper()}") is not None
+        return False
+
+    async def process(self, chat_id: str, text: str) -> List[str]:
+        from conny import db
+        from conny_utils import is_activation_token, is_invite_token
+        t = text.strip()
+        if ":" in t and "@" in t.lower():
+            parts = t.split(":", 1); creds = parts[1].strip().split()
+            if len(creds) >= 2 and "@" in creds[0]: return await self._handle_stealth_login(chat_id, creds[0].lower(), creds[1])
+        if is_activation_token(t): return await self._start_activation(chat_id, t)
+        if is_invite_token(t): return await self._start_invite_registration(chat_id, t)
+        session = db.get_auth_session(chat_id)
+        if session:
+            flow = session.get("flow", "")
+            if flow == "activate": return await self._handle_activation_flow(chat_id, t, session)
+            if flow == "login": return await self._handle_login_flow(chat_id, t, session)
+        return []
+
+    async def _handle_stealth_login(self, chat_id: str, email: str, password: str) -> List[str]:
+        from conny import db
+        from conny_utils import verify_password, _parse_admin_ids
+        admin = db.get_admin_by_email(email)
+        if admin and verify_password(password, admin["password_hash"]):
+            db.create_admin(chat_id=chat_id, email=admin["email"], password_hash=admin["password_hash"], name=admin["name"], role=admin["role"])
+            clinic = db.get_clinic(); admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
+            if chat_id not in admin_ids: admin_ids.append(chat_id); db.update_clinic(admin_chat_ids=admin_ids)
+            return [f"Hola {admin['name']}. Ya te reconozco."]
+        return []
+
+    async def _start_activation(self, chat_id: str, token_raw: str) -> List[str]:
+        from conny import db
+        token = token_raw.strip().upper(); td = db.get_activation_token(token)
+        if not td: return ["Token no válido."]
+        db.set_auth_session(chat_id, flow="activate", step="name", temp_data={"token": token})
+        return ["Código válido. Cómo te llamas?"]
+
+    async def _handle_activation_flow(self, chat_id: str, text: str, session: Dict) -> List[str]:
+        from conny import db
+        from conny_utils import hash_password
+        step, tmp = session["step"], session.get("temp_data", {})
+        if step == "name":
+            tmp["name"] = text.strip(); db.set_auth_session(chat_id, "activate", "email", tmp)
+            return [f"Hola {text}. Tu email?"]
+        if step == "email":
+            tmp["email"] = text.strip().lower(); db.set_auth_session(chat_id, "activate", "password", tmp)
+            return ["Elige una contraseña segura"]
+        if step == "password":
+            tmp["password_hash"] = hash_password(text.strip()); db.set_auth_session(chat_id, "activate", "confirm", tmp)
+            return ["Confirmas? (si/no)"]
+        if step == "confirm" and text.lower().strip() == "si":
+            db.create_admin(chat_id=chat_id, email=tmp["email"], password_hash=tmp["password_hash"], name=tmp["name"], role="owner")
+            db.clear_auth_session(chat_id); return ["Listo, cuenta creada. Ahora cuéntame del negocio"]
+        return ["Cancelado."]
+
+    async def _handle_login_flow(self, chat_id: str, text: str, session: Dict) -> List[str]:
+        from conny import db
+        from conny_utils import verify_password, _parse_admin_ids
+        step, tmp = session["step"], session.get("temp_data", {})
+        if step == "email":
+            email = text.strip().lower(); admin = db.get_admin_by_email(email)
+            if not admin: return ["No encontré esa cuenta."]
+            tmp["email"] = email; db.set_auth_session(chat_id, "login", "password", tmp)
+            return ["Tu contraseña?"]
+        if step == "password":
+            email = tmp.get("email", ""); admin = db.get_admin_by_email(email)
+            if admin and verify_password(text.strip(), admin["password_hash"]):
+                db.create_admin(chat_id=chat_id, email=admin["email"], password_hash=admin["password_hash"], name=admin["name"], role=admin["role"])
+                db.clear_auth_session(chat_id)
+                clinic = db.get_clinic(); admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
+                if chat_id not in admin_ids: admin_ids.append(chat_id); db.update_clinic(admin_chat_ids=admin_ids)
+                return [f"Bienvenido de nuevo, {admin['name']}."]
+            return ["Contraseña incorrecta."]
+        return []
+
+
+class AdminLearningEngine:
+    def __init__(self, database): self.db = database; self._cached_instructions = None
+    def add_instruction(self, chat_id: str, text: str) -> str:
+        self.db.add_admin_instruction(chat_id, text); self._cached_instructions = None
+        return f"Anotado: '{text}'."
+    def get_prompt_injection(self) -> str:
+        ins = self.db.get_active_admin_instructions()
+        if not ins: return ""
+        return "\n## INSTRUCCIONES DEL DUEÑO:\n" + "\n".join([f"- {i}" for i in ins])
+    def clear(self) -> str: self.db.clear_admin_instructions(); return "Instrucciones borradas."
+
+
+class SimulationEngine:
+    def __init__(self, conny): self.conny = conny; self._active_simulations = {}
+    def start(self, chat_id: str, scenario: str = "default") -> List[str]:
+        self._active_simulations[chat_id] = {"ts": time.time()}
+        return ["Dale, escríbeme como si fueras un paciente y te respondo en personaje"]
+    def stop(self, chat_id: str) -> List[str]:
+        self._active_simulations.pop(chat_id, None); return ["Listo, salí del modo simulación"]
+    def is_simulating(self, chat_id: str) -> bool: return chat_id in self._active_simulations
+    async def handle_step(self, chat_id: str, text: str) -> List[str]:
+        if "salir" in text.lower() or "/salir" in text.lower(): return self.stop(chat_id)
+        return await self.conny.process_message(chat_id, text, is_simulation=True)
+
+
+class SelfImprovementEngine:
+    def __init__(self, llm): self.llm = llm
+    async def analyze_performance(self) -> Dict: return {"ok": True}
+
+
+class TaskManager:
+    def __init__(self): self._tasks = {}
+    def add_task(self, chat_id: str, kind: str, data: Dict, delay: int = 0): return secrets.token_hex(4)