@innvisor/conny-ai 9.7.0 → 9.8.2

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## 9.8.2 - 2026-06-02
+
+- persisted the language selected in `conny init` so the rest of the CLI loads it automatically
+- made `conny_i18n` read the saved workspace language on startup
+- kept the `conny init` banner unchanged while aligning other launch paths to the same brand
+
+## 9.8.1 - 2026-06-02
+
+- made `conny` open the guided setup flow by default instead of the old help banner
+- removed the default launcher banner from the primary `conny` path
+- aligned the TUI version display with `package.json`
+
+## 9.8.0 - 2026-06-02
+
+- blocked first-contact setup for unknown chats until a valid activation token is provided
+- added `conny token --admin` with `ADMN-` Conny Pro Admin tokens, offline SQLite generation and web/API developer access
+- fixed token casing and case-insensitive token lookup so generated tokens validate reliably
+- made `/api/activate`, web registration and developer registration accept Conny Pro Admin tokens safely
+- added admin Soul memory folders under `soul/admins/<chat_id>` for persistent operator context and learned business/ops facts
+- introduced typed LLM service errors so quota/API-key failures are shown to admins before any fallback
+- changed admin fallback into an explicit opt-in flow via `continuar fallback`
+- cleaned npm packaging to exclude patch/fix scripts and private per-business brand asset folders
+- fixed first contact greeting regression (`Holaal`) and restored admin capability fallback for audios, PDFs and documents
+
+## 9.7.6 - 2026-05-26
+
+- fixed demo LLM resolution through the Conny facade so tests and runtime use the configured engine instead of a stale runtime module
+- removed the fake “internet dropped” demo fallback and replaced it with contextual owner onboarding when every model response is empty or unusable
+- preserved continuity in owner demo flows so Conny does not repeat “soy una IA” after capability context was already explained
+- verified Python, Node/npm and shell entrypoints for Linux/macOS/PowerShell-compatible npm usage
+
+## 9.7.5 - 2026-05-26
+
+- unified `conny init`, `conny config` and `conny doctor` around the active instance `.env`
+- mirrored provisioned instance secrets and URLs into the base runtime `.env` after setup and config edits
+- replaced brittle `.env` text replacement with parser-based updates that handle quoted, unquoted and `pending` values
+- added dashboard exposure setup to `conny init` for localhost, LAN/IP and custom public URLs
+
+## 9.7.4 - 2026-05-26
+
+- fixed existing installs with a stale/incomplete Python runtime by making bootstrap health check required imports before every command
+- added `conny --bootstrap-check` and wired the shell installer to run it before reporting success
+- ensured missing `rich`/CLI dependencies are repaired during install instead of surfacing later at `conny init`
+
+## 9.7.3 - 2026-05-26
+
+- fixed Termux/proot installs where `conny init` could start without `rich` installed
+- made the npm bootstrap install critical CLI dependencies first and fail loudly if they are missing
+- kept heavy production dependencies best-effort so packages like `scikit-learn` cannot leave the CLI half-installed
+- expanded runtime health checks to include `rich`, `deep_translator`, `questionary`, `fastapi`, `httpx`, `dotenv` and `pydantic`
+
+## 9.7.2 - 2026-05-26
+
+- removed the obsolete boxed `CONNY ULTRA CONFIG v9.7.0` layout from `conny config`
+- added a Gateway/Webhook step to `conny init` with automatic `localhost.run` tunneling or manual `BASE_URL`
+- fixed tunnel routing to target the active instance `PORT` instead of stale defaults like `8002`
+- made webhook sync reload the real `.env` and restart PM2 with `--update-env` before calling Telegram `setWebhook`
+- unified the default instances path under `~/.conny/instances`
+
+## 9.7.1 - 2026-05-26
+
+- fixed GitHub/npm bootstrap for fresh installs where `conny init` still tried to run from `/home/ubuntu/conny`
+- removed the hardcoded working directory in `conny_app.py`; subcommands now run from the installed `CONNY_DIR`
+- bumped the package version so existing `~/.conny/repo` installs resync automatically on reinstall
+- kept the public package name as `conny-ai` for GitHub installs and npm compatibility
+
 ## 9.7.0 - 2026-05-26
 
 - corregido el arranque PM2 para usar `run.sh` y selección dinámica de Python, evitando `--interpreter python3` duro y rutas rotas de venv

package/README.md

@@ -123,6 +123,22 @@ It's a **white-label AI receptionist platform** that lets you sell branded conve
 
 ### Step 1 — Install Conny
 
+Recommended GitHub installer (always tracks the current `main` branch):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/sxrubyo/conny/latest/install.sh | bash
+conny --version
+```
+
+Direct GitHub install with npm:
+
+```bash
+npm install -g github:sxrubyo/conny#main
+conny --version
+```
+
+Registry install:
+
 ```bash
 npm install -g conny-ai
 conny --version
@@ -242,7 +258,7 @@ backups/                 # Local backups
 ## 🎮 CLI Reference
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/sxrubyo/conny/main/install.sh | bash
+curl -fsSL https://raw.githubusercontent.com/sxrubyo/conny/latest/install.sh | bash
 conny --version                  # Check version
 
 conny sync --list                # List all client instances

package/conny_app.py

@@ -43,6 +43,8 @@ TAGLINES = [
 ]
 
 BOOT_FILE = Path.home() / ".conny" / ".boot_shown"
+APP_DIR = Path(os.environ.get("CONNY_DIR", str(Path(__file__).resolve().parent))).resolve()
+INSTANCES_DIR = Path(os.environ.get("INSTANCES_DIR", str(Path.home() / ".conny" / "instances"))).resolve()
 
 
 # ─── Boot ─────────────────────────────────────────────────────────────────────
@@ -156,7 +158,7 @@ def cmd_status(args=""):
     con.print(); con.print(Padding(t,(0,2))); con.print()
 
 def cmd_list(args=""):
-    idir = Path("/home/ubuntu/conny-instances")
+    idir = INSTANCES_DIR
     if not idir.exists(): con.print("  [dim]no instances[/dim]"); return
     t = Table(box=box.SIMPLE, border_style=COLORS["primary"], show_edge=False, padding=(0,1))
     t.add_column("", width=3); t.add_column("name", style="bold")
@@ -264,7 +266,11 @@ def _uptime(ms):
     return f"{int(s/86400)}d"
 
 def _py(*a):
-    try: subprocess.run([sys.executable]+[str(x) for x in a],cwd="/home/ubuntu/conny")
+    try:
+        env = os.environ.copy()
+        env.setdefault("CONNY_DIR", str(APP_DIR))
+        env.setdefault("INSTANCES_DIR", str(INSTANCES_DIR))
+        subprocess.run([sys.executable]+[str(x) for x in a],cwd=str(APP_DIR),env=env)
     except Exception as e: con.print(f"  [err]{e}[/err]")
 
 def _sh(*a):
@@ -279,7 +285,7 @@ def main():
     if first_run() and not (len(sys.argv)>1 and sys.argv[1] in ("help","--help","-h","-v","--version")):
         onboard()
     if len(sys.argv) <= 1:
-        cmd_help()
+        cmd_new()
     else:
         route(sys.argv[1], " ".join(sys.argv[2:]))
 

package/conny_cli.py

@@ -250,7 +250,7 @@ def build_pm2_start_command(instance_dir: str, pm2_name: str, log_dir: str) -> L
     ]
 
 
-VERSION = "9.7.0"
+VERSION = "9.8.0"
 CONNY_HOME = os.getenv("CONNY_HOME", str(Path.home() / ".conny"))
 CONNY_DIR = os.getenv("CONNY_DIR", str(Path(__file__).resolve().parent))
 INSTANCES_DIR = _default_instances_dir()
@@ -876,7 +876,7 @@ def prompt(label, default="", secret=False):
     d = f" [{default}]" if default else ""
     try:
         import getpass
-        v = getpass.getpass(f"\n  {q(C.P2, '▸')}  {label}{q(C.G3, d)}  ") if secret else input(f"\n  {q(C.P2, '▸')}  {label}{q(C.G3, d)}  ")
+        v = input(f"\n  {q(C.P2, '▸')}  {label}{q(C.G3, d)}  ") if secret else input(f"\n  {q(C.P2, '▸')}  {label}{q(C.G3, d)}  ")
     except (EOFError, KeyboardInterrupt):
         print()
         return default
@@ -6296,11 +6296,15 @@ def cmd_token(args):
     
     Uso:
       conny token                    → genera para la instancia base
+      conny token --admin            → genera token Conny Pro Admin
       conny token 1                  → genera para la instancia 1
       conny token "Clinica Demo"     → genera con ese nombre
       conny token all                → genera para todas las instancias
     """
     name = getattr(args, 'name', '') or getattr(args, 'subcommand', '') or ''
+    admin_mode = bool(getattr(args, "admin", False)) or name.lower() in ("--admin", "admin", "pro")
+    if name.lower() in ("--admin", "admin", "pro"):
+        name = ""
 
     def _gen_token(inst, label_override=""):
         ev = dict(load_env(f"{inst.dir}/.env"))
@@ -6310,11 +6314,67 @@ def cmd_token(args):
             return
         label = label_override or inst.label
         base_url = f"http://localhost:{inst.port}"
+        payload = {"clinic_label": label}
+        if admin_mode:
+            payload["token_type"] = "admin_pro"
+            payload["admin"] = True
+
+        def _print_token(token, expires, offline=False):
+            kind = "Conny Pro Admin" if admin_mode else "activación"
+            suffix = " offline" if offline else ""
+            ok(f"Token {kind}{suffix} generado para: {q(C.YLW, label)}")
+            print(f"\n    {q(C.YLW, token, bold=True)}\n")
+            info(f"Expira: {expires}")
+            if admin_mode:
+                info("Activa el modo operador: el admin lo escribe en WhatsApp/Telegram para tomar control de la instancia.")
+            else:
+                info("Envialo al admin — lo escribe en el chat de WhatsApp/Telegram")
+
+        def _gen_offline(reason: str):
+            import secrets as _secrets
+            import re as _re
+            db_path = inst.db_path
+            if not db_path:
+                fail(f"No se pudo generar: {reason}")
+                return
+            label_clean = _re.sub(r'[^a-zA-Z0-9]', '', label.lower())[:10].upper() or ("ADMIN" if admin_mode else "GENERIC")
+            entropy = _secrets.token_hex(18 if admin_mode else 16).upper()
+            token = f"{'ADMN' if admin_mode else 'ACTV'}-{label_clean}-{entropy}"
+            expires_at = (datetime.now() + timedelta(hours=72)).isoformat()
+            stored_label = f"ADMIN_PRO:{label}" if admin_mode else label
+            try:
+                os.makedirs(os.path.dirname(db_path), exist_ok=True)
+                conn = sqlite3.connect(db_path)
+                cur = conn.cursor()
+                cur.execute("""
+                    CREATE TABLE IF NOT EXISTS activation_tokens (
+                        token TEXT PRIMARY KEY,
+                        clinic_label TEXT NOT NULL,
+                        expires_at TEXT NOT NULL,
+                        used_at TEXT,
+                        used_by_chat_id TEXT,
+                        is_active INTEGER DEFAULT 1,
+                        created_at TEXT DEFAULT (datetime('now'))
+                    )
+                """)
+                cur.execute("""
+                    INSERT INTO activation_tokens
+                    (token, clinic_label, expires_at, created_at)
+                    VALUES (?, ?, ?, ?)
+                """, (token, stored_label, expires_at, datetime.now().isoformat()))
+                conn.commit()
+                conn.close()
+                warn(f"API local no disponible ({reason}); usé generación offline segura.")
+                _print_token(token, expires_at[:16], offline=True)
+            except Exception as offline_error:
+                fail(f"No se pudo generar: {reason}")
+                fail(f"Fallback offline falló: {offline_error}")
+
         try:
             if _HTTPX:
                 r = _httpx.post(
                     f"{base_url}/api/tokens/create",
-                    json={"clinic_label": label},
+                    json=payload,
                     headers={"X-Master-Key": master_key},
                     timeout=10
                 )
@@ -6323,7 +6383,7 @@ def cmd_token(args):
                 import urllib.request as _ur
                 req = _ur.Request(
                     f"{base_url}/api/tokens/create",
-                    data=json.dumps({"clinic_label": label}).encode(),
+                    data=json.dumps(payload).encode(),
                     headers={"Content-Type": "application/json", "X-Master-Key": master_key},
                     method="POST"
                 )
@@ -6331,15 +6391,11 @@ def cmd_token(args):
             token = data.get("token", "")
             expires = data.get("expires_at", "")[:16] if data.get("expires_at") else "72h"
             if token:
-                ok(f"Token generado para: {q(C.YLW, label)}")
-                print(f"\n    {q(C.YLW, token, bold=True)}\n")
-                info(f"Expira: {expires}")
-                info("Envialo al admin — lo escribe en el chat de WhatsApp/Telegram")
+                _print_token(token, expires)
             else:
-                fail(f"Error: {data}")
+                _gen_offline(f"respuesta API sin token: {data}")
         except Exception as e:
-            fail(f"No se pudo generar: {e}")
-            info(f"¿Está corriendo? conny restart {inst.name}")
+            _gen_offline(str(e))
 
     # Generar para todas
     if name.lower() in ("all", "todas", "todos"):
@@ -7126,6 +7182,40 @@ def cmd_sync_web(args):
     ok(f"Instancia {inst.label} vinculada y sincronizada correctamente.")
     info("Puedes gestionarla desde el portal web usando tu token.")
 
+
+
+def cmd_dev_account(args):
+    """Crea una cuenta de desarrollador para la UI web."""
+    print("\n══ Cuenta de Desarrollador (Web Dev Console) ══")
+    import os, sqlite3, secrets, hashlib
+    import getpass
+    
+    db_path = "/home/ubuntu/conny/conny_ultra.db"
+    if not os.path.exists(db_path):
+        db_path = "/home/ubuntu/conny/conny.db"
+        
+    email = input(f"  {q(C.CYN, 'Email del Dev:')} ").strip().lower()
+    if not email: return
+    password = getpass.getpass(f"  {q(C.CYN, 'Contraseña:')} ").strip()
+    if not password: return
+    
+    try:
+        salt = secrets.token_hex(16)
+        key = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt.encode("utf-8"), 260_000).hex()
+        hashed = f"{salt}:{key}"
+        
+        conn = sqlite3.connect(db_path)
+        c = conn.cursor()
+        c.execute("CREATE TABLE IF NOT EXISTS dev_accounts (email TEXT PRIMARY KEY, password_hash TEXT)")
+        c.execute("INSERT OR REPLACE INTO dev_accounts (email, password_hash) VALUES (?, ?)", (email, hashed))
+        conn.commit()
+        conn.close()
+        ok(f"Cuenta '{email}' creada con éxito.")
+        info("Ya puedes entrar en la web mediante el botón 'API Access / Conny Dev'.")
+    except Exception as e:
+        fail(f"Error al crear cuenta localmente: {e}")
+
+
 ROUTES = {
 
     "auth": cmd_auth,
@@ -7134,6 +7224,7 @@ ROUTES = {
     "portal": cmd_portal,
     "web": cmd_portal,
     "sync-web": cmd_sync_web,
+    "dev-account": cmd_dev_account, "dev": cmd_dev_account,
     # Principal
     "init": cmd_init,
     "new": cmd_new, "nuevo": cmd_new, "crear": cmd_new,
@@ -11699,6 +11790,7 @@ def main():
     parser.add_argument("--quiet", "-q", action="store_true")
     parser.add_argument("--json", "-j", action="store_true", help="Output JSON")
     parser.add_argument("--auto", "-y", action="store_true", help="Auto-confirm")
+    parser.add_argument("--admin", action="store_true", help="Genera token Conny Pro Admin")
     parser.add_argument("--dry-run", "-n", action="store_true", dest="dry_run",
                         help="Preview sin ejecutar (sync)")
     parser.add_argument("--no-restart", action="store_true", dest="no_restart",

package/conny_core/evolution.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+import os
+import re
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+log = logging.getLogger("conny.evolution")
+
+class EvolutionManager:
+    """
+    Maneja la auto-evolución de Conny.
+    Escribe en SOUL.md e IDENTITY.md y persiste cambios en DB.
+    """
+
+    def __init__(self, instance_id: str, db, instance_path: Optional[Union[str, Path]] = None):
+        self.instance_id = instance_id
+        self.db = db
+        # Intentar determinar la ruta de la instancia
+        if instance_path:
+            self.base_path = Path(instance_path)
+        else:
+            self.base_path = Path(f"/home/ubuntu/conny-instances/{instance_id}")
+            if not self.base_path.exists():
+                self.base_path = Path(".") # Fallback
+
+        self.soul_path = self.base_path / "soul" / "SOUL.md"
+        self.identity_path = self.base_path / "identity" / "IDENTITY.md"
+        
+        # Asegurar que los directorios existen
+        self.soul_path.parent.mkdir(parents=True, exist_ok=True)
+        self.identity_path.parent.mkdir(parents=True, exist_ok=True)
+
+    async def apply_instruction(self, text: str) -> str:
+        """
+        Analiza un mensaje del admin y aplica cambios si detecta instrucciones de evolución.
+        """
+        text_low = text.lower().strip()
+        
+        # 1. Cambio de Saludo
+        saludo_match = re.search(r"(?:cambia|pon|usa|setea)\s+(?:tu|el)\s+saludo\s+(?:a|por|como)\s+[\"']?(.+?)[\"']?$", text, re.IGNORECASE)
+        if saludo_match:
+            new_greeting = saludo_match.group(1).strip()
+            # Si el saludo tiene |||, lo dividimos en dos burbujas
+            if "|||" in new_greeting:
+                g1, g2 = [p.strip() for p in new_greeting.split("|||", 1)]
+                self.db.update_clinic(custom_greeting_1=g1, custom_greeting_2=g2)
+            else:
+                self.db.update_clinic(custom_greeting_1=new_greeting)
+            
+            await self._update_soul(f"El admin pidió cambiar el saludo a: {new_greeting}")
+            return f"entendido, ya actualicé mi saludo a: {new_greeting}"
+
+        # 2. Frases prohibidas
+        forbidden_match = re.search(r"(?:no\s+uses|no\s+digas|deja\s+de\s+usar|prohibido\s+decir)\s+(?:la\s+frase|la\s+palabra|el\s+termino)?\s*[\"']?(.+?)[\"']?$", text, re.IGNORECASE)
+        if forbidden_match:
+            phrase = forbidden_match.group(1).strip()
+            # Guardar en business_rules
+            clinic = self.db.get_clinic()
+            rules = clinic.get("business_rules", {})
+            if isinstance(rules, str): rules = json.loads(rules)
+            
+            forbidden = rules.get("forbidden_phrases", [])
+            if phrase not in forbidden:
+                forbidden.append(phrase)
+            rules["forbidden_phrases"] = forbidden
+            
+            self.db.update_clinic(business_rules=json.dumps(rules, ensure_ascii=False))
+            await self._update_soul(f"REGLA CRÍTICA: No usar jamás la frase o palabra: '{phrase}'")
+            return f"anotado. no volveré a decir '{phrase}' nunca más"
+
+        # 3. Datos del Admin
+        if "me llamo" in text_low or "mi nombre es" in text_low:
+            name_match = re.search(r"(?:me llamo|soy|mi nombre es)\s+([A-ZÁÉÍÓÚ][a-záéíóú]+(?:\s+[A-ZÁÉÍÓÚ][a-záéíóú]+)?)", text)
+            if name_match:
+                admin_name = name_match.group(1)
+                await self._update_identity(f"Nombre del Administrador: {admin_name}")
+                # El profile ya se actualiza en runtime.py, pero esto refuerza los archivos .md
+                return f"mucho gusto {admin_name}, ya guardé tu nombre en mi identidad operativa"
+
+        return ""
+
+    async def _update_soul(self, observation: str):
+        """Añade una observación al archivo SOUL.md."""
+        try:
+            content = ""
+            if self.soul_path.exists():
+                content = self.soul_path.read_text(encoding="utf-8")
+            
+            new_entry = f"\n- [{datetime.now().strftime('%Y-%m-%d %H:%M')}] {observation}"
+            if "# EVOLUCIÓN" not in content:
+                content += "\n\n# EVOLUCIÓN\n"
+            
+            content += new_entry
+            self.soul_path.write_text(content, encoding="utf-8")
+        except Exception as e:
+            log.error(f"Error updating SOUL.md: {e}")
+
+    async def _update_identity(self, line: str):
+        """Actualiza o añade una línea al archivo IDENTITY.md."""
+        try:
+            content = ""
+            if self.identity_path.exists():
+                content = self.identity_path.read_text(encoding="utf-8")
+            
+            if line not in content:
+                content += f"\n- {line}"
+                self.identity_path.write_text(content, encoding="utf-8")
+        except Exception as e:
+            log.error(f"Error updating IDENTITY.md: {e}")

package/conny_core/first_turn_ops.py

@@ -48,29 +48,25 @@ def _strip_leading_greeting(text: str) -> str:
 
 
 def _first_contact_intro(clinic: Dict[str, Any], agent_name: str = "Conny") -> str:
-    clinic_name = (clinic.get("name") or "").strip()
-    if clinic_name:
-        return f"Hola! Soy {agent_name} de {clinic_name}."
-    return f"Hola! Soy {agent_name}."
+    # ── Override del Admin ──────────────────────────────────────────────
+    manual = clinic.get("custom_greeting_1")
+    if manual:
+        return manual
+        
+    clinic_name = str(clinic.get("name") or "").strip()
+    if clinic_name:
+        return f"Hola, soy {agent_name} de {clinic_name}"
+    return f"Hola, soy {agent_name}"
 
 
 def _first_contact_welcome_line(clinic: Dict[str, Any], user_msg: str) -> str:
-    clinic_name = (clinic.get("name") or "").strip()
-    normalized = _normalize_conv_text(user_msg or "")
-    if "buenas tardes" in normalized:
-        opening = "Hola, buenas tardes"
-    elif "buenos dias" in normalized:
-        opening = "Hola, buenos días"
-    elif "buenas noches" in normalized:
-        opening = "Hola, buenas noches"
-    elif "buenas" in normalized:
-        opening = "Hola, buenas"
-    else:
-        opening = "Hola"
-    
-    if clinic_name:
-        return f"{opening}! Bienvenido a {clinic_name}."
-    return f"{opening}! Cómo estás?"
+    # ── Override del Admin ──────────────────────────────────────────────
+    manual = clinic.get("custom_greeting_2")
+    if manual:
+        return manual
+
+    # ── Saludo por Defecto (Upgrade) ───────────────────────────────────
+    return "Gracias por contactarte con nosotros como te puedo ayudar??"
 
 
 def _first_contact_identity_line(clinic: Dict[str, Any], agent_name: str = "Conny") -> str:

package/conny_core/prompt_ops.py

@@ -34,6 +34,68 @@ def truncate_block(text: str, max_chars: int) -> str:
     return f"{clipped}..."
 
 
+def build_business_context(clinic: dict, db, instance_path: str = None) -> str:
+    """
+    Construye el contexto del negocio para el system prompt.
+    Lee de DB + archivos de knowledge si existen.
+    """
+    parts = []
+    
+    name = clinic.get("name", "")
+    if name:
+        parts.append(f"Negocio: {name}")
+    
+    services = clinic.get("services", "")
+    if isinstance(services, list):
+        services = ", ".join(services)
+    if services:
+        parts.append(f"Servicios: {services}")
+    
+    prices = clinic.get("prices", "") or clinic.get("pricing", "")
+    if isinstance(prices, dict):
+        prices = ", ".join(f"{k}: {v}" for k, v in prices.items())
+    if prices:
+        parts.append(f"Precios: {prices}")
+    
+    schedule = clinic.get("schedule", "") or clinic.get("hours", "")
+    if isinstance(schedule, dict):
+        schedule = ", ".join(f"{k}: {v}" for k, v in schedule.items())
+    if schedule:
+        parts.append(f"Horarios: {schedule}")
+    
+    address = clinic.get("address", "") or clinic.get("location", "")
+    if address:
+        parts.append(f"Ubicación: {address}")
+    
+    # Leer archivos de knowledge si existen
+    if instance_path:
+        import os
+        from pathlib import Path
+        # Intentar varias rutas comunes para knowledge
+        paths_to_try = [
+            Path(instance_path) / "knowledge",
+            Path(f"instances/{instance_path}/knowledge"),
+            Path(f"/home/ubuntu/conny/instances/{instance_path}/knowledge"),
+            Path(f"knowledge/{instance_path}")
+        ]
+        
+        for knowledge_dir in paths_to_try:
+            if knowledge_dir.exists():
+                for md_file in sorted(knowledge_dir.glob("*.md"))[:5]:  # max 5 archivos
+                    try:
+                        content = md_file.read_text(encoding="utf-8").strip()
+                        if content:
+                            parts.append(f"\n--- {md_file.stem} ---\n{content[:1000]}")
+                    except Exception:
+                        pass
+                break # Si encontramos uno que existe, paramos
+    
+    if not parts:
+        return "El negocio no ha completado su configuración todavía."
+    
+    return "\n".join(parts)
+
+
 def build_compact_examples(examples: str, max_chars: int = 650, max_lines: int = 16) -> str:
     if not examples:
         return ""

package/conny_demo_voice.py

@@ -129,6 +129,6 @@ def get_closing_response() -> str:
     """When prospect wants to buy, close with Santiago's contact."""
     return (
         "me alegra que te haya gustado la demo! |||"
-        " para activarlo en tu negocio, Santiago te explica todo: 3124348669 |||"
+        " para activarlo en tu negocio, Santiago te explica todo: 3243699856 |||"
         " la activación es rápida, en menos de 5 minutos ya estoy respondiendo tu WhatsApp"
     )