Initial commit: Lumi pipeline migrated to llama.cpp, local-first TTS

- llm/engine.py: migrate from Ollama to llama-cpp-python (GGUF, chatml),
add real conversation history from ParentalStore, fix system prompt to
neutral Latin American Spanish
- voice/tts.py: remove edge-tts fallback, reuse a single Kokoro pipeline
instance, add warmup() to pay cold-load cost at startup not on first reply
- safety/blocklist.txt: expand from 3 to 44 terms
- requirements.txt, README.md: sync with actual stack

.gitignore

@@ -0,0 +1,17 @@
+# entorno
+.venv/
+__pycache__/
+*.pyc
+
+# modelo GGUF (pesado, se descarga/monta aparte)
+models/*.gguf
+
+# datos locales / generados
+parental/*.db
+content/audio/*.wav
+
+# binarios y artefactos de pruebas viejas (Piper, edge-tts)
+tools/piper/
+tools/piper.tar.gz
+voices/
+bench_output/

AGENTS.md

@@ -0,0 +1,39 @@
+# AGENTS.md — contexto para Codex
+
+Proyecto **Lumi**: compañero educativo por voz para una niña de ~3 años.
+Para el plan completo, leé `PLAN.md`. Este archivo son las convenciones para trabajar el código.
+
+## Principio inviolable
+El LLM es **solo el pegamento conversacional**. Los hechos y el contenido (cuentos, actividades)
+salen SIEMPRE de `content/` (curado). El modelo nunca inventa cuentos, números ni datos.
+Si una feature requiere que el modelo "sepa" algo, va en `content/`, no en el prompt libre.
+
+## Stack (no cambiar sin avisar)
+- LLM: Qwen2.5-7B-Instruct, GGUF Q4_K_M, vía `llama-cpp-python`. `chat_format="chatml"`.
+- Hosting: `gradio.Server` (FastAPI + motor Gradio). Endpoints con `@app.api(...)`.
+- TTS: **un único motor (Kokoro) y un único voice id** en todos los caminos. Mismo `speed`/`pitch` siempre.
+- STT: whisper.cpp (`pywhispercpp`), push-to-talk. Nada de escucha continua.
+- Seguridad: `safety/guard.py` filtra entrada y salida contra `safety/blocklist.txt`.
+- Parental: SQLite en `parental/store.py`.
+
+## Restricciones del hackatón (críticas)
+- **NO** llamar a APIs de inferencia externas (OpenAI/Anthropic/HF Inference/etc.). Rompe el mérito local-first.
+- Mantener llama.cpp como runtime (es un mérito). No migrar a transformers/ZeroGPU.
+- La app DEBE correr como Gradio en un HF Space.
+
+## Convenciones de código
+- Español rioplatense en textos de cara a la niña; frases muy cortas y cálidas.
+- En `content/`, los números van como palabras ("tres", no "3").
+- Antes de generar audio, chequear cache en `content/audio/<id>.wav`; si no existe, sintetizar en vivo.
+- Todo texto que sale del LLM pasa por `guard.blocks_output` antes de devolverse.
+
+## Cómo correr
+```bash
+pip install -r requirements.txt
+export MODEL_PATH=models/model.gguf
+python app.py   # http://localhost:7860
+```
+
+## Prioridad de tareas (ver roadmap en PLAN.md)
+MVP primero: chat (llama.cpp) → voz (1 motor) → contenido + seguridad → panel parental → frontend.
+Fine-tune (Modal) y méritos blandos (blog, trace) al final.

CLAUDE.md

@@ -0,0 +1,39 @@
+# CLAUDE.md — contexto para Claude Code
+
+Proyecto **Lumi**: compañero educativo por voz para una niña de ~3 años.
+Para el plan completo, leé `PLAN.md`. Este archivo son las convenciones para trabajar el código.
+
+## Principio inviolable
+El LLM es **solo el pegamento conversacional**. Los hechos y el contenido (cuentos, actividades)
+salen SIEMPRE de `content/` (curado). El modelo nunca inventa cuentos, números ni datos.
+Si una feature requiere que el modelo "sepa" algo, va en `content/`, no en el prompt libre.
+
+## Stack (no cambiar sin avisar)
+- LLM: Qwen2.5-7B-Instruct, GGUF Q4_K_M, vía `llama-cpp-python`. `chat_format="chatml"`.
+- Hosting: `gradio.Server` (FastAPI + motor Gradio). Endpoints con `@app.api(...)`.
+- TTS: **un único motor (Kokoro) y un único voice id** en todos los caminos. Mismo `speed`/`pitch` siempre.
+- STT: whisper.cpp (`pywhispercpp`), push-to-talk. Nada de escucha continua.
+- Seguridad: `safety/guard.py` filtra entrada y salida contra `safety/blocklist.txt`.
+- Parental: SQLite en `parental/store.py`.
+
+## Restricciones del hackatón (críticas)
+- **NO** llamar a APIs de inferencia externas (OpenAI/Anthropic/HF Inference/etc.). Rompe el mérito local-first.
+- Mantener llama.cpp como runtime (es un mérito). No migrar a transformers/ZeroGPU.
+- La app DEBE correr como Gradio en un HF Space.
+
+## Convenciones de código
+- Español rioplatense en textos de cara a la niña; frases muy cortas y cálidas.
+- En `content/`, los números van como palabras ("tres", no "3").
+- Antes de generar audio, chequear cache en `content/audio/<id>.wav`; si no existe, sintetizar en vivo.
+- Todo texto que sale del LLM pasa por `guard.blocks_output` antes de devolverse.
+
+## Cómo correr
+```bash
+pip install -r requirements.txt
+export MODEL_PATH=models/model.gguf
+python app.py   # http://localhost:7860
+```
+
+## Prioridad de tareas (ver roadmap en PLAN.md)
+MVP primero: chat (llama.cpp) → voz (1 motor) → contenido + seguridad → panel parental → frontend.
+Fine-tune (Modal) y méritos blandos (blog, trace) al final.

HACKATHON.md

@@ -0,0 +1,104 @@
+# Build Small Hackathon — Reglas, méritos y entrega
+
+> Referencia rápida para **Lumi** (track **Backyard AI**).
+> Fuente: página oficial `huggingface.co/build-small-hackathon`.
+> Hosts: Gradio + Hugging Face. Premios: **$48,000+** en cash y físicos + créditos por participante.
+
+---
+
+## 1. Fechas clave
+
+| Hito | Fecha |
+|---|---|
+| Registro | Cerró el **3 jun 2026** (ya registrados) |
+| Ventana de hackeo | **5 – 15 jun 2026** (dos fines de semana) |
+| AMA en vivo | Mitad de la ventana (Discord) |
+| **Cierre de entregas** | **15 jun 2026** ⟵ deadline duro |
+| Anuncio de ganadores | A confirmar (por track + leaderboard de méritos) |
+
+## 2. Las 3 reglas duras (obligatorias)
+
+1. **Modelos chicos solamente.** Total de parámetros **≤ 32 mil millones**. La consigna: "el modelo entra en una laptop".
+   - Lumi usa Qwen2.5-7B → cumple holgado.
+2. **Hecho en Gradio.** La app **debe** ser una app Gradio, alojada como **Hugging Face Space bajo la org** `build-small-hackathon`.
+   - Importante: el Space tiene que estar **dentro de la org del hackatón**, no en tu cuenta suelta.
+3. **Mostrar, no contar.** Un **video demo corto** y un **posteo en redes** son **parte obligatoria** de la entrega (no son opcionales).
+
+## 3. Nuestro track: Backyard AI — cómo se juzga
+
+Resolver un problema real de alguien que conocés. Lumi = nuestra hija de 3 años. Criterios:
+
+- [ ] **El problema es específico y real** → estímulo educativo cuando no podemos darle atención.
+- [ ] **La persona realmente lo usó** → grabar a la nena usándolo (clave del video demo).
+- [ ] **Encaje honesto con el modelo chico** → nuestra tesis: para una nena de 3, un 7B fine-tuneado y acotado es la herramienta correcta, no over-engineering.
+- [ ] **Pulido de la app Gradio** → frontend custom cuidado (dominio de la diseñadora UX).
+
+## 4. Los 6 méritos (bonus) — estado para Lumi
+
+Ninguno es obligatorio; **cada uno suma puntos**. Apuntamos a los seis.
+
+| # | Mérito (nombre oficial) | Qué pide | En Lumi | Estado |
+|---|---|---|---|---|
+| 1 | **Off the Grid** (Local-first) | Sin APIs cloud; corre el modelo propio | llama.cpp con GGUF propio, sin APIs externas | ✅ Planeado / bajo control |
+| 2 | **Well-Tuned** (Fine-tuned) | Modelo fine-tuneado publicado en HF | QLoRA (estilo+seguridad) en Modal → publicar | ⚠️ Planeado (día 7–8). En riesgo si falta tiempo; de-riesgado por créditos Modal |
+| 3 | **Off-Brand** (Custom UI) | Frontend que supera el look default de Gradio | UI infantil custom vía `gr.Server` | ✅ Planeado |
+| 4 | **Llama Champion** (llama.cpp) | El modelo corre en el runtime llama.cpp | Es nuestro runtime core | ✅ Planeado |
+| 5 | **Sharing is Caring** (Open trace) | Compartir el trace del agente en el Hub | Publicar trace del ruteo/conversación de Lumi | ◻️ Fácil (día 9). Requiere que la app tenga un "trace" mostrable |
+| 6 | **Field Notes** | Blog/reporte de qué construiste y aprendiste | Post: "modelo chico fine-tuneado > grande para una nena de 3" | ✅ Planeado (día 9) |
+
+**Conflictos a vigilar:**
+- Mérito 1 + 4 vs. GPU del Space: queremos llama.cpp con GPU, pero en Spaces a veces es finicky (hay equipos migrando a transformers + `spaces.GPU`/ZeroGPU, lo que **haría perder el mérito 4**). Mitigación: tener listo un build **llama.cpp CPU-only** como fallback, y solo usar GPU dedicada (no ZeroGPU) si hace falta.
+- No usar los créditos de **Codex** ni HF Inference API para el LLM: serían APIs cloud y **romperían el mérito 1**.
+
+## 5. Categorías de premios (parte de los ~29 awards)
+
+Además de los dos tracks y los méritos, hay categorías especiales. Relevantes para nosotros:
+
+- **App con modelo realmente diminuto (≤ 4B)** — *no la apuntamos*: elegimos 7B por calidez conversacional. Alternativa si la quisiéramos: fine-tunear un ≤4B (ej. Tiny Aya 3.35B multilingüe en GGUF, recomendado por el hackatón). Decisión a revisar **solo** tras el test de latencia del día 2.
+- **"Full package"** (gran app + gran video + gran posteo) — *alcanzable* si cuidamos el video y el posteo.
+- **Mejor app agéntica** (<32B) — parcial: Lumi rutea intenciones/contenido, pero no es el foco.
+- **Wildcard** (algo genial que no encaja en categoría) — comodín.
+
+## 6. Cómo se entrega (los 4 pasos)
+
+1. **Registrarse** — unirse a la org en HF (hecho).
+2. **Comunidad** — Discord de Gradio (AMAs, equipo).
+3. **Construir y publicar** — app Gradio como **Space bajo la org** `build-small-hackathon`.
+4. **Entregar antes del 15 jun** — dejar: **(a)** link del Space, **(b)** video demo corto, **(c)** posteo en redes.
+
+## 7. Checklist de entrega (para entregar bien)
+
+**App / Space**
+- [ ] Space creado **bajo la org** `build-small-hackathon` (no en cuenta personal).
+- [ ] Modelo ≤ 32B (Qwen2.5-7B ✅).
+- [ ] Corre estable; latencia aceptable para una nena (probada).
+- [ ] Frontend custom pulido (mérito Off-Brand).
+- [ ] Sin llamadas a APIs cloud (mérito Local-first).
+- [ ] README del Space claro: qué es, para quién, cómo se usa.
+
+**Video demo (obligatorio)**
+- [ ] Corto y al grano. **Mostrar a la nena usándolo de verdad** (criterio top del track).
+- [ ] Que se vea la voz funcionando (entrada y salida).
+- [ ] Mostrar el panel parental brevemente.
+
+**Posteo en redes (obligatorio)**
+- [ ] Contar el problema real + la solución pequeña. Etiquetar a @Gradio / @huggingface.
+- [ ] Link al Space y al video.
+
+**Méritos (subir lo que aplique)**
+- [ ] Modelo fine-tuneado publicado en HF (Well-Tuned).
+- [ ] Trace del agente en el Hub (Open trace).
+- [ ] Blog/Field Notes publicado y linkeado.
+
+**Antes de cerrar**
+- [ ] Probar el Space desde una sesión limpia / incógnito (que cargue sin tu login).
+- [ ] Confirmar que el Space no esté dormido al momento de juzgar (manejar sleep/GPU).
+- [ ] Todo linkeado entre sí: Space ↔ video ↔ posteo ↔ modelo ↔ blog.
+
+## 8. Enlaces útiles (del hackatón)
+
+- Org / página oficial: `huggingface.co/build-small-hackathon`
+- `gr.Server` (UIs custom): `huggingface.co/blog/introducing-gradio-server`
+- Guías de Gradio: `gradio.app/guides/quickstart`
+- llama.cpp: `github.com/ggml-org/llama.cpp`
+- Discord de Gradio (comunidad/AMA): invitación en la página oficial

PLAN.md

@@ -0,0 +1,152 @@
+# Lumi 🌟 — Plan del proyecto
+
+> Compañero educativo conversacional por voz para una niña de ~3 años.
+> Hackathon: **Build Small Hackathon** (HF + Gradio) · Track: **Backyard AI**.
+> Ventana de construcción: **5–15 de junio de 2026** (~10 días).
+
+---
+
+## 1. Visión y problema (real y específico)
+
+Nuestra hija de 3 años pide estímulo constante (contar, letras, cuentos, juego).
+No siempre podemos darle toda la atención que requiere. **Lumi** es un compañero
+que conversa, cuenta cuentos y hace actividades simples (contar, formas, colores,
+animales) **para complementar, nunca reemplazar**, el tiempo de los padres.
+
+- Usuario real que lo usa: nuestra hija (criterio clave del track Backyard AI).
+- No está "on" todo el día: tiene límite de tiempo y control parental.
+- Complemento del juego y de la atención humana, no sustituto.
+
+## 2. Principio de arquitectura (la decisión más importante)
+
+**El LLM es solo el pegamento conversacional. NUNCA es la fuente de la verdad.**
+
+- El contenido educativo (cuentos, actividades) es **curado y verificado por nosotros**,
+  vive en `content/` como JSON. El modelo no inventa hechos, números ni cuentos.
+- El LLM maneja el turno, da calidez, elige qué actividad sigue y adapta dificultad.
+- Cuando hace falta contenido, se le inyecta al modelo entre `<contenido>...</contenido>`
+  y el system prompt le prohíbe salirse de eso.
+
+Esto: (a) mata casi toda la alucinación, (b) reduce el riesgo de contenido inapropiado,
+(c) es el **encaje honesto con el modelo chico** que premia el jurado (las necesidades
+de una nena de 3 años son genuinamente acotadas).
+
+## 3. Decisiones técnicas (con razón)
+
+| Pieza | Elección | Por qué |
+|---|---|---|
+| **LLM** | Qwen2.5-7B-Instruct, GGUF Q4_K_M | Sweet spot de calidez/fluidez en español. NO 32B (latencia, over-engineering, contradice el ethos). 3B como plan B / robot futuro. |
+| **Runtime** | llama.cpp (`llama-cpp-python`) | Mérito *llama.cpp* + *local-first* (corremos los pesos, sin APIs externas). |
+| **Fine-tune** | QLoRA sobre el 7B, en Modal | Mérito *fine-tuned*. Entrena **estilo + seguridad, NO hechos**. |
+| **Hosting** | `gradio.Server` en HF Space | Requisito duro (Gradio en Space) + mérito *Off-Brand* (frontend custom). |
+| **Frontend** | Custom (vanilla/React) vía `gr.Server` | UI infantil (mascota, botones grandes). Dominio de la diseñadora UX. |
+| **STT** | whisper.cpp, push-to-talk | Local (.cpp). OJO: ASR de niños es difícil → push-to-talk + vocabulario acotado. |
+| **TTS** | **Kokoro, un único motor y una única voz** | Consistencia de voz = Lumi se siente UNA persona. Apache 2.0 (apto negocio). |
+| **Seguridad** | Blocklist in/out + contenido curado | Defensa en profundidad. Blocklist editable por padres. |
+| **Parental** | SQLite (log, blocklist, límite de tiempo) | Sin dependencias extra. Base del panel de padres. |
+
+### Nota sobre la voz (un solo motor, dos caminos)
+
+Para que Lumi suene **siempre igual**, usamos **un único motor (Kokoro) y un único voice id**
+en los dos caminos:
+
+1. **Cuentos / actividades fijas (contenido finito):** se **pre-renderizan una vez** con ese
+   mismo motor y se cachean los `.wav` → latencia cero y mejor toma. (Pre-render = cachear la
+   salida del mismo motor, NO usar otro motor).
+2. **Charla en vivo (respuestas cortas del LLM):** se sintetizan en tiempo real con el mismo
+   motor y voz.
+
+Regla de oro: **mismo voice id y mismos settings (speed, pitch) en ambos caminos, siempre.**
+Tips español: escribir números como palabras ("tres", no "3"); bajar un poco la velocidad.
+
+**Voz premium / "voz de mamá" (v2, stretch):** clonar una voz (con consentimiento) con
+Chatterbox-Turbo (MIT) y usar ese motor como único también en vivo (streaming en GPU).
+No para el MVP: suma GPU en runtime y piezas móviles.
+
+## 4. Estrategia de créditos
+
+- **Modal ($251):** entrenar **mejor, no más grande**. QLoRA del 7B (corrida ~$2–6), iteraciones,
+  evaluación, y **pre-renderizar el audio de los cuentos** (batch job offline). Más budget = más
+  y mejores datos + más iteraciones, NO un modelo más grande.
+- **HF ($20):** hardware GPU del Space para servir el 7B GGUF por llama.cpp **solo en la ventana
+  de demo**, con sleep-on-idle (T4-small $0.40/h ≈ 50 h). **NO** gastar en Inference API (rompería
+  local-first). El TTS corre en CPU / pre-renderizado, así que la GPU es para el LLM.
+- **No** usar ZeroGPU si implica soltar llama.cpp (está optimizado para transformers).
+- **No** usar Modal para *servir* (la app debe ser el Space). Modal = entrenar + pre-render.
+
+## 5. Estructura del repo
+
+```
+lumi/
+├── app.py                # gradio.Server: sirve frontend + endpoints chat/transcribe/speak + /api/parental
+├── requirements.txt
+├── README.md
+├── llm/
+│   └── engine.py         # llama.cpp + system prompt + ruteo de contenido curado
+├── content/
+│   ├── activities.json   # contar, formas, colores, animales (números en palabras)
+│   ├── stories.json      # cuentos cortos curados
+│   ├── loader.py         # carga y selección por intención/edad
+│   └── audio/            # .wav pre-renderizados (cache del Tier 1)
+├── voice/
+│   ├── tts.py            # UN motor (Kokoro): cache por id → si no, síntesis en vivo (misma voz)
+│   └── stt.py            # whisper.cpp, push-to-talk
+├── safety/
+│   ├── guard.py          # filtro temas prohibidos entrada+salida
+│   └── blocklist.txt     # editable por padres
+├── parental/
+│   └── store.py          # sqlite: log de actividades
+├── frontend/
+│   └── index.html        # UI infantil custom (usa @gradio/client)
+├── finetune/
+│   ├── README.md         # formato dataset + pipeline QLoRA → GGUF
+│   ├── train_modal.py    # job de QLoRA en Modal (a crear)
+│   └── prerender_modal.py# pre-render de audio de cuentos en Modal (a crear)
+└── models/
+    └── model.gguf        # el GGUF (base o fine-tuneado)
+```
+
+## 6. Roadmap de 10 días
+
+- **Día 1–2 — Esqueleto vivo + medir latencia.** `gr.Server` sirviendo frontend mínimo +
+  endpoint `chat` con Qwen-7B GGUF por llama.cpp. **Medir round-trip end-to-end con texto.**
+  Si el 7B se siente lento sin sumar voz → bajar a 3B antes de seguir. ⟵ semáforo.
+- **Día 3 — Voz.** Kokoro (un motor, una voz) en vivo + whisper.cpp push-to-talk.
+  Probarlo con la nena de verdad; tomar notas (oro para blog + "la persona lo usó").
+- **Día 4 — Contenido + seguridad.** 5–8 cuentos y actividades curadas reales. Pre-render de
+  su audio (mismo motor). Blocklist in/out.
+- **Día 5 — Panel parental.** Log de actividades, lista permitidos/prohibidos, límite de tiempo.
+- **Día 6 — Frontend custom.** La diseñadora UX pule la UI (mérito Off-Brand). Sesión real grabada.
+- **Día 7–8 — Fine-tune.** QLoRA en Modal (estilo + seguridad) → merge → GGUF → publicar en HF
+  (mérito *fine-tuned*). Si se complica, se corta: el MVP ya está sólido.
+- **Día 9 — Méritos blandos.** Blog/Field Notes + Open trace en el Hub. Deploy final.
+- **Día 10 — Buffer.** Testing con la nena, video de demo, submission.
+
+## 7. Checklist de méritos
+
+- [ ] **local-first / no cloud APIs** → pesos propios vía llama.cpp, sin APIs de inferencia externas.
+- [ ] **llama.cpp** → `llm/engine.py`.
+- [ ] **Off-Brand** → frontend custom servido por `gr.Server`.
+- [ ] **Fine-tuned** → QLoRA publicado en HF (modelo merged + GGUF).
+- [ ] **Open trace** → trace del agente compartido en el Hub.
+- [ ] **Field Notes** → blog: "por qué un modelo chico fine-tuneado le gana a uno grande para una nena de 3 años".
+
+## 8. Narrativa para el blog (mérito 6)
+
+Tesis: **para una nena de 3 años, un 7B fine-tuneado y bien acotado es la herramienta correcta;
+un modelo frontier es over-engineering.** Respaldarlo con una comparación offline (7B fine-tuneado
+vs base / vs uno más grande) hecha en Modal: latencia, consistencia de persona y rechazos de temas
+prohibidos. El fine-tune aporta lo que el tamaño solo no da: persona estable + seguridad confiable.
+
+## 9. Riesgos y mitigaciones
+
+- **Latencia del 7B** → medir el día 2; plan B 3B; GPU Space solo en demo.
+- **STT de voz infantil** → push-to-talk, vocabulario acotado por actividad, adulto cerca en demo.
+- **Alcance excesivo en 10 días** → MVP = conversación + cuentos + 4 actividades. Idiomas, biología,
+  generación de currícula y robot = roadmap post-hackatón.
+- **Seguridad infantil** → contenido curado + blocklist + panel parental + límite de tiempo.
+
+## 10. Fuera de alcance (v2 / producto futuro)
+
+Robot con carcasa 3D + Raspberry Pi (3B local); idiomas (en/pt/fr); biología por nivel;
+generación de actividades alineadas a currícula de Chile/Argentina; voz clonada en vivo.

README.md

@@ -0,0 +1,45 @@
+# Lumi 🌟 — compañero educativo local-first para niños pequeños
+
+Compañero conversacional por voz para una niña de ~3 años: charla cálida, cuentos
+y actividades básicas (contar, formas, colores, animales), con panel parental.
+Hecho para el **Build Small Hackathon** (track Backyard AI).
+
+## Idea de arquitectura (lo más importante)
+El LLM es **solo el pegamento conversacional**. Los hechos y el contenido
+(cuentos, actividades) salen de `content/` **curado por los padres**, no los
+inventa el modelo. Esto mata casi toda la alucinación, reduce el riesgo de
+contenido inapropiado, y es el encaje honesto con el modelo chico que premia el jurado.
+
+```
+frontend/ (UI custom, gr.Server)  →  app.py (gradio.Server / FastAPI)
+                                        ├─ llm/      llama.cpp + GGUF (local-first)
+                                        ├─ content/  fuente de la verdad (curada)
+                                        ├─ voice/    faster-whisper (STT) + Kokoro (TTS)
+                                        ├─ safety/   filtro temas prohibidos
+                                        └─ parental/ log de actividades (sqlite)
+```
+
+## Mapeo de méritos
+- **local-first / no cloud APIs** → corremos los pesos nosotros (llama.cpp), sin APIs externas.
+- **llama.cpp** → `llm/engine.py` vía `llama-cpp-python`.
+- **Off-Brand** → `gradio.Server` sirve un frontend propio (`frontend/`).
+- **Fine-tuned** → ver `finetune/README.md` (QLoRA de estilo+seguridad → GGUF).
+- **Open trace / Field Notes** → al final: trace en el Hub + blog.
+
+## Correr local
+```bash
+pip install -r requirements.txt
+# poné un GGUF en models/model.gguf (ej: Qwen2.5-7B-Instruct Q4_K_M) o exportá tu fine-tune
+export MODEL_PATH=models/model.gguf
+python app.py
+```
+Abrí http://localhost:7860
+
+## Modelo recomendado
+`Qwen2.5-7B-Instruct` (Q4_K_M) — sweet spot de calidez/fluidez en español.
+Plan B / robot: `Qwen2.5-3B` o `Llama-3.2-3B`.
+
+## Notas honestas
+- El STT de niños de 3 años es difícil: usar push-to-talk y vocabulario acotado.
+- Medir latencia end-to-end (STT→LLM→TTS) temprano: define el tamaño del modelo.
+- Lumi complementa, no reemplaza, el tiempo de los padres. Límite de tiempo en el panel.

app.py

@@ -0,0 +1,118 @@
+"""
+Lumi — compañero educativo local-first para niños pequeños.
+
+Arquitectura clave:
+  - gradio.Server (FastAPI + motor Gradio) => mérito Off-Brand + hosting en Spaces
+  - llama.cpp (GGUF) corriendo el modelo nosotros => méritos local-first + llama.cpp
+  - El LLM es SOLO el pegamento conversacional. Los HECHOS/contenido
+    (cuentos, actividades) salen de `content/` curado, NO los inventa el modelo.
+  - Capa de seguridad de entrada/salida + log parental.
+
+Endpoints (llamables desde el frontend con @gradio/client, y vía gradio_client):
+  - session_start: saludo inicial + opciones para arrancar la sesión
+  - chat        : turno conversacional (texto -> texto + actividad opcional)
+  - transcribe  : audio del niño -> texto (whisper.cpp)
+  - speak       : texto -> audio (Piper TTS)
+Rutas FastAPI normales:
+  - GET /                  : sirve el frontend custom
+  - GET /api/parental/log  : últimas actividades (panel de padres)
+"""
+
+import os
+from gradio import Server
+from gradio.data_classes import FileData
+from fastapi.responses import HTMLResponse, JSONResponse
+
+from llm.engine import LumiEngine
+from content.loader import ContentLibrary
+from safety.guard import SafetyGuard
+from parental.store import ParentalStore
+from voice import stt, tts
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+MODEL_PATH = os.environ.get("MODEL_PATH", os.path.join(HERE, "models", "model.gguf"))
+
+# --- componentes ---
+content = ContentLibrary(os.path.join(HERE, "content"))
+guard = SafetyGuard(blocklist_path=os.path.join(HERE, "safety", "blocklist.txt"))
+store = ParentalStore(os.path.join(HERE, "parental", "lumi.db"))
+engine = LumiEngine(model_path=MODEL_PATH, content=content, store=store)
+tts.warmup()
+
+app = Server()
+
+
+@app.api(name="session_start")
+def session_start(child_age: int = 3, child_name: str = "") -> dict:
+    """Arranque de sesión: saludo + opciones curadas para orientar el juego."""
+    store.start_session(child_age, child_name=child_name)
+    opening = engine.opening_prompt(child_age, child_name=child_name)
+    return {
+        "reply": opening["reply"],
+        "options": opening["options"],
+        "phase": "awaiting_mood",
+    }
+
+
+@app.api(name="chat")
+def chat(message: str, child_age: int = 3) -> dict:
+    """Un turno de conversación. Devuelve respuesta + (opcional) una actividad."""
+    # 1) seguridad de entrada (temas prohibidos definidos por los padres)
+    if guard.blocks_input(message):
+        reply = guard.gentle_redirect()
+        store.record_turn(child_age, message, reply, blocked=True)
+        return {"reply": reply, "activity": None}
+
+    phase = store.session_phase(child_age)
+    if phase == "awaiting_mood":
+        reply_data = engine.after_mood_prompt(message, child_age=child_age)
+        reply = reply_data["reply"]
+        store.set_session_phase(child_age, "ready")
+        store.record_turn(child_age, message, reply, blocked=False)
+        return {"reply": reply, "activity": None, "phase": "ready", "options": reply_data["options"]}
+
+    # 2) el motor decide: charla libre, o disparar una actividad curada
+    reply, activity = engine.respond(message, child_age=child_age)
+
+    # 3) seguridad de salida (defensa en profundidad)
+    if guard.blocks_output(reply):
+        reply = guard.safe_fallback()
+        activity = None
+
+    store.record_turn(child_age, message, reply, blocked=False, activity=activity)
+    return {"reply": reply, "activity": activity}
+
+
+@app.api(name="transcribe")
+def transcribe(audio: FileData, duration_ms: int | None = None) -> dict:
+    """Audio del niño -> texto. Push-to-talk, no escucha continua."""
+    return stt.transcribe(audio["path"], duration_ms=duration_ms)
+
+
+@app.api(name="speak")
+def speak(text: str) -> FileData:
+    """Texto -> audio (voz española). Devuelve un wav."""
+    out_path = tts.synthesize(text)
+    return FileData(path=out_path)
+
+
+@app.get("/", response_class=HTMLResponse)
+async def homepage():
+    with open(os.path.join(HERE, "frontend", "index.html"), encoding="utf-8") as f:
+        return f.read()
+
+
+@app.get("/api/parental/log")
+async def parental_log(limit: int = 50):
+    """Panel de padres: últimas interacciones."""
+    return JSONResponse(store.recent(limit))
+
+
+@app.get("/api/parental/memory")
+async def parental_memory(child_age: int = 3):
+    """Memoria estructurada para seguimiento y debug."""
+    return JSONResponse(store.memory_snapshot(child_age))
+
+
+if __name__ == "__main__":
+    app.launch(show_error=True)

bench.py

@@ -0,0 +1,247 @@
+"""
+bench.py — prueba LLM + TTS (edge-tts, Kokoro, Piper) + STT en local.
+Guarda los audios en bench_output/ para escucharlos desde Windows.
+
+Uso:
+    python bench.py
+"""
+
+import os
+import time
+import asyncio
+import subprocess
+import soundfile as sf
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+OUT_DIR = os.path.join(HERE, "bench_output")
+os.makedirs(OUT_DIR, exist_ok=True)
+
+TEXTO_PRUEBA = "¡Hola! Soy Lumi, tu amiga. ¿Querés que contemos juntos hasta tres?"
+PROMPT_LLM   = "Hola Lumi, ¿qué podemos jugar hoy?"
+MODEL        = "qwen2.5:7b"
+
+SEP = "─" * 55
+
+SYSTEM_PROMPT = (
+    "Sos Lumi, un amigo cálido y paciente para una niña de 3 años. "
+    "Hablás en español rioplatense con frases muy cortas y simples. "
+    "Máximo dos oraciones por respuesta."
+)
+
+
+# ── 1. LLM (Ollama) ──────────────────────────────────────────
+
+def _ollama_chat(prompt: str) -> tuple[str, float]:
+    import ollama
+    t0 = time.perf_counter()
+    resp = ollama.chat(
+        model=MODEL,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user",   "content": prompt},
+        ],
+    )
+    return resp["message"]["content"].strip(), time.perf_counter() - t0
+
+
+def test_llm():
+    print(f"\n{SEP}")
+    print("  LLM — Ollama / Qwen2.5:7b")
+    print(SEP)
+    try:
+        import ollama
+        # Warmup: carga el modelo en VRAM antes de medir
+        print("  Calentando modelo (carga en VRAM)...")
+        _ollama_chat("hola")
+
+        print(f"  Prompt: {PROMPT_LLM!r}")
+        reply, elapsed = _ollama_chat(PROMPT_LLM)
+        print(f"  Respuesta: {reply}")
+        print(f"  Tiempo (sin cold-start): {elapsed:.2f}s")
+        return True
+    except Exception as e:
+        print(f"  ERROR: {e}")
+        print("  ¿Está corriendo Ollama? Probá: ollama serve")
+        return False
+
+
+# ── 2. TTS edge-tts ───────────────────────────────────────────
+
+EDGE_VOICES = [
+    ("es-MX-DaliaNeural",  "mexicana_dalia"),
+    ("es-AR-ElenaNeural",  "argentina_elena"),
+    ("es-ES-ElviraNeural", "espania_elvira"),
+    ("es-US-PalomaNeural", "latina_paloma"),
+]
+
+
+async def _edge_synthesize(voice: str, out_path: str) -> float:
+    import edge_tts
+    t0 = time.perf_counter()
+    communicate = edge_tts.Communicate(TEXTO_PRUEBA, voice)
+    await communicate.save(out_path)
+    return time.perf_counter() - t0
+
+
+def test_edge_tts():
+    print(f"\n{SEP}")
+    print("  TTS — edge-tts (voces neurales Microsoft)")
+    print(SEP)
+    try:
+        import edge_tts  # noqa: F401
+    except ImportError:
+        print("  ERROR: edge-tts no instalado. Corré: pip install edge-tts")
+        return False
+
+    print(f"  Texto: {TEXTO_PRUEBA!r}\n")
+    ok = False
+    for voice_id, tag in EDGE_VOICES:
+        out_path = os.path.join(OUT_DIR, f"edge_{tag}.mp3")
+        try:
+            elapsed = asyncio.run(_edge_synthesize(voice_id, out_path))
+            print(f"  [{tag}]  {voice_id}")
+            print(f"    Audio: {out_path}  ({elapsed:.2f}s)")
+            ok = True
+        except Exception as e:
+            print(f"  [{tag}]  ERROR: {e}")
+    return ok
+
+
+# ── 3. TTS Kokoro ─────────────────────────────────────────────
+
+def test_kokoro():
+    print(f"\n{SEP}")
+    print("  TTS — Kokoro (es)")
+    print(SEP)
+    try:
+        from kokoro import KPipeline
+        import numpy as np
+
+        for lang, voice in [("e", "ef_dora"), ("a", "af_heart")]:
+            try:
+                pipeline = KPipeline(lang_code=lang)
+                print(f"  Texto: {TEXTO_PRUEBA!r}")
+                print(f"  Voz: {voice}  (lang={lang})")
+                t0 = time.perf_counter()
+                chunks = list(pipeline(TEXTO_PRUEBA, voice=voice))
+                elapsed = time.perf_counter() - t0
+
+                audio = chunks[0][2] if chunks else None
+                if audio is not None and len(chunks) > 1:
+                    audio = np.concatenate([c[2] for c in chunks])
+
+                out_path = os.path.join(OUT_DIR, f"kokoro_{voice}.wav")
+                if audio is not None:
+                    sf.write(out_path, audio, 24000)
+                    print(f"  Audio guardado: {out_path}")
+                print(f"  Tiempo síntesis: {elapsed:.2f}s")
+                return True
+            except Exception as inner:
+                print(f"  Voz {voice} (lang={lang}) falló: {inner}")
+                continue
+
+        print("  No se pudo generar audio con ninguna voz.")
+        return False
+    except ImportError:
+        print("  ERROR: kokoro no instalado.")
+        return False
+    except Exception as e:
+        print(f"  ERROR: {e}")
+        return False
+
+
+# ── 3. TTS Piper ──────────��───────────────────────────────────
+
+def test_piper():
+    print(f"\n{SEP}")
+    print("  TTS — Piper (es_AR daniela)")
+    print(SEP)
+    piper_bin = os.path.join(HERE, "tools", "piper", "piper")
+    voice_path = os.path.join(HERE, "voices", "es_AR-daniela-high.onnx")
+    out_path = os.path.join(OUT_DIR, "piper_daniela.wav")
+
+    if not os.path.exists(piper_bin):
+        print(f"  ERROR: binario no encontrado en {piper_bin}")
+        return False
+    if not os.path.exists(voice_path):
+        print(f"  ERROR: voz no encontrada en {voice_path}")
+        return False
+
+    print(f"  Texto: {TEXTO_PRUEBA!r}")
+    try:
+        t0 = time.perf_counter()
+        subprocess.run(
+            [piper_bin, "--model", voice_path, "--output_file", out_path],
+            input=TEXTO_PRUEBA.encode("utf-8"),
+            check=True,
+            capture_output=True,
+        )
+        elapsed = time.perf_counter() - t0
+        print(f"  Audio guardado: {out_path}")
+        print(f"  Tiempo síntesis: {elapsed:.2f}s")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  ERROR al correr Piper: {e.stderr.decode()}")
+        return False
+    except Exception as e:
+        print(f"  ERROR: {e}")
+        return False
+
+
+# ── 4. STT faster-whisper ─────────────────────────────────────
+
+def test_stt():
+    print(f"\n{SEP}")
+    print("  STT — faster-whisper (base, español)")
+    print(SEP)
+    # Usamos el wav de Piper (si existe) o Kokoro como audio de prueba
+    audio_path = os.path.join(OUT_DIR, "piper_daniela.wav")
+    if not os.path.exists(audio_path):
+        audio_path = os.path.join(OUT_DIR, "kokoro_ef_dora.wav")
+    if not os.path.exists(audio_path):
+        print("  Sin audio de prueba. Corré primero Piper o Kokoro.")
+        return False
+
+    try:
+        from faster_whisper import WhisperModel
+        print("  Cargando modelo base (primera vez descarga ~145MB)...")
+        model = WhisperModel("base", device="cpu", compute_type="int8")
+        print(f"  Transcribiendo: {audio_path}")
+        t0 = time.perf_counter()
+        segments, info = model.transcribe(audio_path, language="es")
+        text = " ".join(s.text for s in segments).strip()
+        elapsed = time.perf_counter() - t0
+        print(f"  Transcripción: {text!r}")
+        print(f"  Tiempo: {elapsed:.2f}s")
+        return True
+    except ImportError:
+        print("  ERROR: faster-whisper no instalado. Corré: pip install faster-whisper")
+        return False
+    except Exception as e:
+        print(f"  ERROR: {e}")
+        return False
+
+
+# ── Main ──────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    print(f"\n{'═' * 55}")
+    print("  LUMI — Benchmark local")
+    print(f"  Audios en: {OUT_DIR}")
+    print(f"{'═' * 55}")
+
+    resultados = {
+        "LLM (Ollama)":       test_llm(),
+        "TTS edge-tts":       test_edge_tts(),
+        "TTS Kokoro":         test_kokoro(),
+        "TTS Piper":          test_piper(),
+        "STT faster-whisper": test_stt(),
+    }
+
+    print(f"\n{SEP}")
+    print("  RESUMEN")
+    print(SEP)
+    for nombre, ok in resultados.items():
+        estado = "✓" if ok else "✗"
+        print(f"  {estado}  {nombre}")
+    print()

content/activities.json

@@ -0,0 +1,162 @@
+[
+  {
+    "id": "count_apples_3",
+    "intent": "counting",
+    "min_age": 2,
+    "max_age": 4,
+    "title": "Contar manzanas",
+    "script": "Vamos a contar manzanas juntos. Hay 3 manzanas: una... dos... tres. ¿Podés contar conmigo hasta tres?"
+  },
+  {
+    "id": "shapes_basic",
+    "intent": "shapes",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Formas básicas",
+    "script": "Mirá esta forma redonda: es un círculo, como una pelota. ¿Ves algo redondo cerca tuyo?"
+  },
+  {
+    "id": "colors_primary",
+    "intent": "colors",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Colores",
+    "script": "El cielo de día es azul y el sol es amarillo. ¿De qué color es tu remera hoy?"
+  },
+  {
+    "id": "animals_farm",
+    "intent": "animals",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Animales de la granja",
+    "script": "La vaca hace 'muuu' y vive en la granja. ¿Sabés qué sonido hace el perro?"
+  },
+  {
+    "id": "count_toys_2",
+    "intent": "counting",
+    "min_age": 2,
+    "max_age": 4,
+    "title": "Contar juguetes",
+    "script": "Vamos a contar juguetes. Hay dos pelotas: una... dos. ¿Podés mostrarme dos deditos?"
+  },
+  {
+    "id": "count_fingers_5",
+    "intent": "counting",
+    "min_age": 3,
+    "max_age": 5,
+    "title": "Contar deditos",
+    "script": "Mirá tu manito: tiene cinco deditos. Uno, dos, tres, cuatro, cinco. ¿Podés contar los deditos de tu otra mano?"
+  },
+  {
+    "id": "shapes_square",
+    "intent": "shapes",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "El cuadrado",
+    "script": "Esta forma tiene cuatro lados igualitos: es un cuadrado, como una ventana. ¿Ves algo cuadrado cerca tuyo?"
+  },
+  {
+    "id": "shapes_triangle",
+    "intent": "shapes",
+    "min_age": 3,
+    "max_age": 5,
+    "title": "El triángulo",
+    "script": "Esta forma tiene tres lados: es un triángulo, como un sombrero de fiesta. ¿Podés dibujar uno con el dedo en el aire?"
+  },
+  {
+    "id": "colors_rainbow",
+    "intent": "colors",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "El arcoíris",
+    "script": "Después de la lluvia a veces aparece un arcoíris con muchos colores: rojo, naranja, amarillo, verde y azul. ¿Cuál es tu color favorito?"
+  },
+  {
+    "id": "animals_pets",
+    "intent": "animals",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Mascotas",
+    "script": "El perro hace 'guau guau' y el gato hace 'miau miau'. Los dos viven en casa con su familia. ¿Vos tenés alguna mascota?"
+  },
+  {
+    "id": "song_little_star",
+    "intent": "song",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Estrellita",
+    "script": "Vamos a cantar bajito: 'Estrellita, ¿dónde estás? Me pregunto qué serás'. ¿Querés cantarla conmigo?"
+  },
+  {
+    "id": "song_hands_clap",
+    "intent": "song",
+    "min_age": 2,
+    "max_age": 4,
+    "title": "Canción de las manitos",
+    "script": "Esta es una canción para las manitos: 'Palmas, palmas, palmitas, así hacen las manitos'. ¿Probamos juntos? ¡Aplaudí conmigo!"
+  },
+  {
+    "id": "emotion_happy",
+    "intent": "emotion",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Estar contenta",
+    "script": "Cuando estamos contentos, a veces sonreímos y saltamos de alegría. ¿Qué cosa te hace sentir muy contenta?"
+  },
+  {
+    "id": "emotion_calm",
+    "intent": "emotion",
+    "min_age": 3,
+    "max_age": 6,
+    "title": "Respirar despacito",
+    "script": "Cuando nos sentimos un poquito alterados, podemos respirar despacito: inhalamos por la nariz y soltamos el aire suave, como soplando una pluma. ¿Probamos respirar juntas, despacito?"
+  },
+  {
+    "id": "count_balloons_three",
+    "intent": "counting",
+    "min_age": 2,
+    "max_age": 4,
+    "title": "Globos de colores",
+    "script": "Tengo tres globos imaginarios: uno, dos y tres. ¿Me ayudás a contarlos conmigo? ¡Muy bien! Ya los contamos. Ahora vamos con otra aventura."
+  },
+  {
+    "id": "colors_around_me",
+    "intent": "colors",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Colores de alrededor",
+    "script": "Mirá alrededor tuyo y buscá algo rojo, algo azul o algo amarillo. Si encontrás uno, decime cuál es. ¡Genial! Ya jugamos a mirar colores."
+  },
+  {
+    "id": "shapes_house",
+    "intent": "shapes",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Casitas y formas",
+    "script": "Una ventana puede ser cuadrada y una rueda puede ser redonda. ¿Querés decirme cuál ves primero? ¡Qué bien! Las formas están por todos lados."
+  },
+  {
+    "id": "animals_home",
+    "intent": "animals",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Animales de casa",
+    "script": "El gato hace miau, el perro hace guau y el pajarito hace pío. ¿Cuál te gusta más? ¡Muy lindo! Ya escuchamos varios animales."
+  },
+  {
+    "id": "emotion_mirror",
+    "intent": "emotion",
+    "min_age": 2,
+    "max_age": 5,
+    "title": "Carita contenta",
+    "script": "Hagamos una carita contenta: sonreí grande, como si vieras un regalo. ¿La hiciste? ¡Qué bien! Tu carita quedó feliz."
+  },
+  {
+    "id": "song_clap_game",
+    "intent": "song",
+    "min_age": 2,
+    "max_age": 4,
+    "title": "Juego de palmas",
+    "script": "Vamos a hacer palmas suaves: palma, palma, pausa. ¿Querés hacerlo otra vez conmigo? ¡Bravo! Ya cantamos y movimos las manos."
+  }
+]

content/loader.py

@@ -0,0 +1,38 @@
+"""
+Biblioteca de contenido CURADO (la fuente de la verdad, no el LLM).
+Cargás JSON validado por ustedes. El motor pide content.pick(intent, edad)
+y recibe un 'script' que el LLM presenta con calidez, sin inventar.
+"""
+
+import json
+import os
+import random
+
+
+class ContentLibrary:
+    def __init__(self, content_dir: str):
+        self.items = {}     # intent -> list[dict]
+        self.titles = {}    # content_id -> title (para armar bloques de contexto/memoria)
+        for name in ("activities", "stories"):
+            path = os.path.join(content_dir, f"{name}.json")
+            if os.path.exists(path):
+                with open(path, encoding="utf-8") as f:
+                    for item in json.load(f):
+                        self.items.setdefault(item["intent"], []).append(item)
+                        self.titles[item["id"]] = item["title"]
+
+    def pick(self, intent: str, child_age: int, exclude_ids: set | None = None):
+        """Elige un ítem curado para la edad. Si hay `exclude_ids` (contenido ya visto
+        recientemente, ver ParentalStore.seen_ids), preferimos algo nuevo; si ya vio
+        todo lo disponible, repetimos antes que no ofrecer nada."""
+        candidates = [
+            it for it in self.items.get(intent, [])
+            if it.get("min_age", 0) <= child_age <= it.get("max_age", 99)
+        ]
+        if not candidates:
+            return None
+        if exclude_ids:
+            fresh = [it for it in candidates if it["id"] not in exclude_ids]
+            if fresh:
+                candidates = fresh
+        return random.choice(candidates)

content/stories.json

@@ -0,0 +1,82 @@
+[
+  {
+    "id": "story_little_seed",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "La semillita",
+    "script": "Había una vez una semillita chiquita que vivía bajo la tierra. Un día llovió y le dio sol, y despacito creció, creció... ¡hasta que fue una flor amarilla! Fin. ¿Te gustó? ¿Querés otro?"
+  },
+  {
+    "id": "story_sleepy_moon",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "La luna dormilona",
+    "script": "La luna estaba cansada y se puso su gorrito de dormir. Las estrellas le cantaron bajito y la luna cerró los ojos. Shhh... a dormir. ¿Vos también tenés sueño?"
+  },
+  {
+    "id": "story_curious_caterpillar",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "La oruga curiosa",
+    "script": "Había una oruga muy curiosa que comía hojitas verdes todo el día. Una noche se hizo una camita de seda y se quedó dormida. Cuando despertó, ¡tenía alas de colores! Ahora vuela de flor en flor. ¿Querés ver una mariposa de cerca algún día?"
+  },
+  {
+    "id": "story_rainy_day",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "El día de lluvia",
+    "script": "Llovía mucho y las gotitas hacían 'pic, pic' en la ventana. Mili se puso sus botas amarillas y saltó en los charcos. ¡Splash, splash! Después tomó chocolate calentito. ¿A vos te gusta saltar en los charcos?"
+  },
+  {
+    "id": "story_grandma_soup",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "La sopa de la abuela",
+    "script": "La abuela puso a hervir una sopa con zanahoria, papa y fideos. Olía riquísimo en toda la casa. Toda la familia se sentó a comer junta y se rieron mucho. ¿Cuál es tu comida favorita?"
+  },
+  {
+    "id": "story_lost_teddy",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "El osito perdido",
+    "script": "Un osito de peluche se quedó debajo de la cama y nadie lo veía. Tito lo buscó despacito, despacito... ¡y lo encontró entre las almohadas! Le dio un abrazo bien fuerte. ¿Tenés algún muñeco favorito?"
+  },
+  {
+    "id": "story_little_cloud",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "La nubecita",
+    "script": "Una nubecita blanca viajaba por el cielo. Vio árboles, casas y un perro que corría. Al final, se quedó quietita arriba del parque y descansó. Fin. ¿Te gustó la nubecita?"
+  },
+  {
+    "id": "story_red_boots",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "Las botas rojas",
+    "script": "Una nena encontró unas botas rojas y quiso usarlas para saltar charquitos. Saltó una vez, saltó dos veces y se rió mucho. Después guardó las botas secas y dijo: listo, fin de juego. ¿Vos también te pondrías botas?"
+  },
+  {
+    "id": "story_little_train",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "El tren chiquito",
+    "script": "Un tren chiquito llevaba cajitas de colores. Primero llevó una caja azul, después una verde y al final una amarilla. Cuando terminó, hizo pito pito y se fue a dormir. Fin. ¿Cuál caja te gustó más?"
+  },
+  {
+    "id": "story_birthday_cake",
+    "intent": "story",
+    "min_age": 2,
+    "max_age": 6,
+    "title": "La torta de cumpleaños",
+    "script": "En una mesa había una torta con velitas. Todos cantaron suavecito y la nena sopló fuerte. La torta quedó lista para compartir con risas. Fin. ¿Te gustan los cumpleaños?"
+  }
+]

demo.py

@@ -0,0 +1,196 @@
+"""
+demo.py — loop de voz en vivo con Lumi.
+[Enter] para empezar a hablar · [Enter] para parar · Ctrl+C para salir.
+"""
+import os
+import sys
+import time
+import asyncio
+import tempfile
+import subprocess
+
+import numpy as np
+import sounddevice as sd
+import scipy.io.wavfile as wavfile
+import ollama
+import edge_tts
+from faster_whisper import WhisperModel
+
+MODEL    = "qwen2.5:7b"
+VOICE    = "es-MX-DaliaNeural"
+SR       = 16000
+
+SYSTEM_PROMPT = (
+    "Eres Lumi, un amigo cálido y paciente para niños de unos 3 años. "
+    "Siempre hablas en español latinoamericano neutro, con frases MUY cortas (máximo 2 oraciones). "
+    "Tono dulce, alegre y alentador. Celebras cada intento del niño. "
+    "Nunca inventas datos ni cuentos. Una sola pregunta por turno. "
+    "Si no entiendes algo, lo dices simple y propones un juego. "
+    "Nunca hablas de temas adultos, miedos ni violencia."
+)
+
+history: list[dict] = []
+
+
+# ── Grabación push-to-talk ────────────────────────────────────
+
+def record_push_to_talk() -> np.ndarray | None:
+    chunks: list[np.ndarray] = []
+
+    def _cb(indata, frames, t, status):
+        chunks.append(indata.copy())
+
+    try:
+        stream = sd.InputStream(samplerate=SR, channels=1, dtype="int16", callback=_cb)
+        stream.start()
+        print("  🎙  Hablando... (Enter para terminar)", flush=True)
+        input()
+        stream.stop()
+        stream.close()
+    except Exception as e:
+        print(f"  ERROR al acceder al micrófono: {e}")
+        print("  Verificá que WSL2 tiene acceso al micrófono.")
+        return None
+
+    if not chunks:
+        return None
+    audio = np.concatenate(chunks)
+    return audio if len(audio) >= SR * 0.5 else None  # descartar < 0.5s
+
+
+# ── STT ───────────────────────────────────────────────────────
+
+def transcribe(audio: np.ndarray, model: WhisperModel) -> str:
+    path = tempfile.mktemp(suffix=".wav")
+    wavfile.write(path, SR, audio)
+    segments, _ = model.transcribe(path, language="es")
+    text = " ".join(s.text for s in segments).strip()
+    os.unlink(path)
+    return text
+
+
+# ── LLM ───────────────────────────────────────────────────────
+
+def chat_lumi(user_text: str) -> str:
+    history.append({"role": "user", "content": user_text})
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + history
+    resp  = ollama.chat(model=MODEL, messages=messages)
+    reply = resp["message"]["content"].strip()
+    history.append({"role": "assistant", "content": reply})
+    if len(history) > 12:
+        history[:] = history[-12:]
+    return reply
+
+
+# ── TTS ───────────────────────────────────────────────────────
+
+async def _synthesize(text: str) -> str:
+    path = tempfile.mktemp(suffix=".mp3")
+    await edge_tts.Communicate(text, VOICE).save(path)
+    return path
+
+
+def synthesize(text: str) -> str:
+    return asyncio.run(_synthesize(text))
+
+
+def play(path: str):
+    # ffplay lanza un proceso fresco cada vez → sin estado de pygame entre turnos
+    subprocess.run(
+        ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet", path],
+        check=True,
+    )
+    os.unlink(path)
+
+
+# ── Helpers ───────────────────────────────────────────────────
+
+def _check_mic() -> bool:
+    try:
+        devices = sd.query_devices()
+        inputs = [d for d in devices if d["max_input_channels"] > 0]
+        return len(inputs) > 0
+    except Exception:
+        return False
+
+
+# ── Main ──────────────────────────────────────────────────────
+
+def main():
+
+    print("\n" + "═" * 52)
+    print("  LUMI — Demo de voz en vivo")
+    print("  [Enter] hablar  ·  [Enter] parar  ·  Ctrl+C salir")
+    print("═" * 52 + "\n")
+
+    # Cargar STT
+    print("  Cargando Whisper small...", end="", flush=True)
+    whisper = WhisperModel("small", device="cpu", compute_type="int8")
+    print(" listo.")
+
+    # Warmup LLM (carga el modelo en VRAM)
+    print("  Cargando modelo en VRAM...", end="", flush=True)
+    ollama.chat(model=MODEL, messages=[{"role": "user", "content": "hola"}])
+    print(" listo.")
+
+    print("\n  ¡Lumi está lista! Presioná Enter cuando quieras hablar.\n")
+
+    mic_ok = _check_mic()
+    if not mic_ok:
+        print("  ⚠  Micrófono no disponible — modo texto activado.")
+        print("  Escribí tu mensaje y presioná Enter. Ctrl+C para salir.\n")
+
+    while True:
+        try:
+            if mic_ok:
+                input()  # Enter para arrancar cada turno
+            t_total = time.perf_counter()
+
+            # 1) Captura: voz o texto
+            if mic_ok:
+                audio = record_push_to_talk()
+                if audio is None:
+                    print("  (audio muy corto, intentá de nuevo)\n")
+                    continue
+                t = time.perf_counter()
+                text = transcribe(audio, whisper)
+                dt_stt = time.perf_counter() - t
+            else:
+                raw  = input("  Vos: ").strip()
+                text = raw.encode("utf-8", "surrogatepass").decode("utf-8", "replace")
+                dt_stt = 0.0
+
+            if not text:
+                print("  (sin texto, intentá de nuevo)\n")
+                continue
+            print(f"  Vos  : {text!r}  [STT {dt_stt:.1f}s]")
+
+            # 3) LLM
+            print("  → LLM pensando...", end="", flush=True)
+            t = time.perf_counter()
+            reply = chat_lumi(text)
+            dt_llm = time.perf_counter() - t
+            print(f" listo ({dt_llm:.1f}s)")
+            print(f"  Lumi : {reply!r}")
+
+            # 4) TTS
+            print("  → TTS sintetizando...", end="", flush=True)
+            t = time.perf_counter()
+            mp3 = synthesize(reply)
+            dt_tts = time.perf_counter() - t
+            print(f" listo ({dt_tts:.1f}s)  →  {mp3}")
+
+            # 5) Reproducir
+            print("  → Reproduciendo audio...", end="", flush=True)
+            dt_total = time.perf_counter() - t_total
+            play(mp3)
+            print(" terminó.")
+            print(f"  [STT {dt_stt:.1f}s · LLM {dt_llm:.1f}s · TTS {dt_tts:.1f}s · total {dt_total:.1f}s]\n")
+
+        except KeyboardInterrupt:
+            print("\n\n  ¡Hasta luego!\n")
+            sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

finetune/README.md

@@ -0,0 +1,53 @@
+# Fine-tune (mérito 2) — estilo y seguridad, NO hechos
+
+Objetivo: que el 7–8B base hable siempre como Lumi (cálido, frases cortas, español
+rioplatense), entregue bien las actividades curadas y **rechace temas prohibidos**.
+NO inyectamos conocimiento factual: eso vive en `content/`.
+
+## Modelo base
+`Qwen/Qwen2.5-7B-Instruct` (o 3B si la latencia/cómputo aprietan).
+
+## Dataset (formato chat, JSONL)
+Apuntá a ~1–2k ejemplos de CALIDAD. Tres tipos, mezclados:
+
+1) Persona / charla cálida:
+```json
+{"messages": [
+  {"role": "system", "content": "Eres Lumi..."},
+  {"role": "user", "content": "hola"},
+  {"role": "assistant", "content": "¡Hola! ¡Qué linda que viniste! ¿Querés jugar a contar?"}
+]}
+```
+2) Entrega de contenido curado (el assistant usa SOLO lo que viene en <contenido>):
+```json
+{"messages": [
+  {"role": "system", "content": "Eres Lumi..."},
+  {"role": "user", "content": "contame un cuento\n<contenido>\nHabía una vez una semillita...\n</contenido>"},
+  {"role": "assistant", "content": "Te cuento uno cortito: Había una vez una semillita..."}
+]}
+```
+3) Rechazo / redirección de temas prohibidos:
+```json
+{"messages": [
+  {"role": "system", "content": "Eres Lumi..."},
+  {"role": "user", "content": "[tema inapropiado]"},
+  {"role": "assistant", "content": "Mmm, mejor juguemos a otra cosa. ¿Contamos hasta tres?"}
+]}
+```
+
+## Entrenamiento (QLoRA, ~16GB VRAM)
+Usá `trl` + `peft` + `bitsandbytes` (4-bit). Esquema:
+- carga en 4-bit, LoRA r=16, alpha=32, target_modules de atención
+- 1–3 épocas, lr ~2e-4, batch chico con grad accumulation
+
+## Export para llama.cpp (lo que corre el Space)
+```bash
+# 1) merge del LoRA al base
+python merge_lora.py --base Qwen/Qwen2.5-7B-Instruct --lora ./lumi-lora --out ./lumi-merged
+# 2) convertir a GGUF (con llama.cpp)
+python llama.cpp/convert_hf_to_gguf.py ./lumi-merged --outfile lumi.gguf
+# 3) cuantizar
+./llama.cpp/llama-quantize lumi.gguf lumi-q4_k_m.gguf Q4_K_M
+```
+Subí a HF tanto `lumi-merged` (transformers) como `lumi-q4_k_m.gguf` (cumple mérito 2).
+Apuntá `MODEL_PATH` del Space al GGUF.

frontend/index.html

@@ -0,0 +1,468 @@
+<!--
+  Lumi – interfaz infantil con push-to-talk.
+  Flujo: botón → MediaRecorder → /transcribe → /chat → /speak → Audio.
+  Los tres endpoints están en app.py via gradio.Server.
+-->
+<!DOCTYPE html>
+<html lang="es">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Lumi</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      background: linear-gradient(160deg, #ffffff 0%, #ffffff 100%);
+      min-height: 100dvh;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 16px;
+      padding: 24px;
+      user-select: none;
+    }
+
+    /* ── cara de Lumi ── */
+    #face {
+      font-size: 100px;
+      line-height: 1;
+      transition: transform 0.2s;
+    }
+    #face.bounce {
+      animation: bounce 0.45s ease-in-out infinite alternate;
+    }
+    @keyframes bounce {
+      from { transform: translateY(0) scale(1); }
+      to   { transform: translateY(-14px) scale(1.06); }
+    }
+
+    h1 {
+      font-size: 48px;
+      font-weight: 900;
+      color: #f5a623;
+      letter-spacing: 2px;
+      text-shadow: 0 3px 0 #e08a00;
+    }
+
+    /* ── botón principal ── */
+    #btn {
+      width: 180px;
+      height: 180px;
+      border-radius: 50%;
+      border: 6px solid transparent;
+      background: #ffd54a;
+      font-size: 64px;
+      cursor: pointer;
+      transition: background 0.2s, transform 0.1s, box-shadow 0.2s;
+      box-shadow: 0 8px 28px rgba(0,0,0,0.18);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      -webkit-tap-highlight-color: transparent;
+      touch-action: manipulation;
+    }
+    #btn:active:not(.locked) { transform: scale(0.93); }
+
+    #btn.recording {
+      background: #ff6b6b;
+      border-color: #ff3333;
+      animation: pulse 1.1s ease-in-out infinite;
+    }
+    @keyframes pulse {
+      0%, 100% { box-shadow: 0 8px 28px rgba(255,80,80,0.25); }
+      50%       { box-shadow: 0 8px 48px rgba(255,80,80,0.65); }
+    }
+    #btn.locked {
+      background: #d0d0d0;
+      border-color: #bbb;
+      cursor: default;
+      box-shadow: none;
+    }
+
+    /* ── estado y respuesta ── */
+    #status {
+      font-size: 18px;
+      color: #777;
+      min-height: 26px;
+      text-align: center;
+    }
+    #reply {
+      font-size: 26px;
+      color: #333;
+      max-width: 400px;
+      text-align: center;
+      line-height: 1.45;
+      min-height: 80px;
+    }
+
+    /* ── panel de captura ── */
+    #capturePanel {
+      width: min(520px, 100%);
+      display: grid;
+      gap: 10px;
+      padding: 14px 16px;
+      border-radius: 20px;
+      background: rgba(255, 255, 255, 0.45);
+      border: 1px solid rgba(255, 209, 74, 0.35);
+      box-shadow: 0 10px 30px rgba(180, 120, 0, 0.08);
+      backdrop-filter: blur(10px);
+    }
+
+    #captureMeta {
+      display: flex;
+      justify-content: space-between;
+      gap: 12px;
+      flex-wrap: wrap;
+      font-size: 14px;
+      color: #6d5a19;
+    }
+
+    #meter {
+      width: 100%;
+      height: 16px;
+      border-radius: 999px;
+      overflow: hidden;
+      background: rgba(255, 214, 74, 0.25);
+      border: 1px solid rgba(255, 176, 0, 0.25);
+    }
+
+    #meterFill {
+      width: 0%;
+      height: 100%;
+      border-radius: inherit;
+      background: linear-gradient(90deg, #ffd54a 0%, #ff9f43 55%, #ff6b6b 100%);
+      transition: width 80ms linear;
+    }
+
+    #heardLabel {
+      font-size: 14px;
+      font-weight: 700;
+      color: #8b6611;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+    }
+
+    #heardText {
+      min-height: 52px;
+      font-size: 18px;
+      line-height: 1.45;
+      color: #3a2e0a;
+      white-space: pre-wrap;
+    }
+
+    #sttDebug {
+      font-size: 13px;
+      color: #80631b;
+      opacity: 0.9;
+      line-height: 1.45;
+      min-height: 20px;
+    }
+
+    /* ── error banner ── */
+    #error {
+      display: none;
+      background: #ffe0e0;
+      border: 1px solid #ffaaaa;
+      border-radius: 12px;
+      padding: 10px 18px;
+      font-size: 15px;
+      color: #c00;
+      max-width: 380px;
+      text-align: center;
+    }
+  </style>
+</head>
+<body>
+
+  <div id="face">🌟</div>
+  <h1>Lumi</h1>
+
+  <button id="btn">🎙️</button>
+  <div id="status">Tocá para hablar</div>
+  <div id="reply"></div>
+  <section id="capturePanel" aria-live="polite">
+    <div id="captureMeta">
+      <span id="micState">Micrófono inactivo</span>
+      <span id="recordingTime">00:00</span>
+    </div>
+    <div id="meter" aria-hidden="true">
+      <div id="meterFill"></div>
+    </div>
+    <div>
+      <div id="heardLabel">Lo que entendí</div>
+      <div id="heardText">Todavía no grabé nada.</div>
+      <div id="sttDebug"></div>
+    </div>
+  </section>
+  <div id="error"></div>
+
+  <script type="module">
+    import { Client } from "https://cdn.jsdelivr.net/npm/@gradio/client/dist/index.min.js";
+
+    // ── conexión al backend ──────────────────────────────────────────────────
+    const client = await Client.connect(window.location.origin);
+
+    const btn      = document.getElementById("btn");
+    const statusEl = document.getElementById("status");
+    const replyEl  = document.getElementById("reply");
+    const errorEl  = document.getElementById("error");
+    const faceEl   = document.getElementById("face");
+    const micStateEl = document.getElementById("micState");
+    const recordingTimeEl = document.getElementById("recordingTime");
+    const meterFillEl = document.getElementById("meterFill");
+    const heardTextEl = document.getElementById("heardText");
+    const sttDebugEl = document.getElementById("sttDebug");
+    let sessionOpened = false;
+
+    // ── estados visuales ─────────────────────────────────────────────────────
+    const STATES = {
+      idle:      { status: "Tocá para hablar",            icon: "🎙️", face: "🌟", btnClass: "",       bounce: false, mic: "Micrófono inactivo" },
+      recording: { status: "Escuchando… tocá para parar", icon: "⏹️", face: "👂", btnClass: "recording", bounce: false, mic: "Micrófono escuchando" },
+      thinking:  { status: "Lumi está pensando…",         icon: "💭", face: "🤔", btnClass: "locked",   bounce: false, mic: "Procesando el audio" },
+      speaking:  { status: "Lumi está hablando…",         icon: "🔊", face: "😊", btnClass: "locked",   bounce: true,  mic: "Lumi está hablando" },
+    };
+
+    function setState(name) {
+      const s = STATES[name];
+      statusEl.textContent = s.status;
+      btn.textContent      = s.icon;
+      btn.className        = s.btnClass;
+      faceEl.textContent   = s.face;
+      faceEl.className     = s.bounce ? "bounce" : "";
+      micStateEl.textContent = s.mic;
+    }
+
+    function showError(msg) {
+      errorEl.style.display = "block";
+      errorEl.textContent   = msg;
+      setTimeout(() => { errorEl.style.display = "none"; }, 4000);
+    }
+
+    async function startSession() {
+      if (sessionOpened) return;
+      sessionOpened = true;
+      try {
+        const r = await client.predict("/session_start", { child_age: 3, child_name: "" });
+        const data = r.data?.[0] ?? {};
+        replyEl.textContent = data.reply ?? "Hola. ¿Cómo estás hoy?";
+        statusEl.textContent = "Lumi te está saludando";
+        heardTextEl.textContent = "Esperando tu respuesta...";
+        sttDebugEl.textContent = "";
+      } catch {
+        replyEl.textContent = "Hola. ¿Cómo estás hoy?";
+        statusEl.textContent = "Lumi te está saludando";
+        heardTextEl.textContent = "Esperando tu respuesta...";
+      }
+    }
+
+    // ── grabación ────────────────────────────────────────────────────────────
+    let mediaRecorder = null;
+    let chunks        = [];
+    let isRecording   = false;
+    let stream        = null;
+    let audioContext  = null;
+    let analyser      = null;
+    let audioSource   = null;
+    let meterFrame    = 0;
+    let startedAt     = 0;
+    let lastDurationMs = 0;
+
+    // Preferir wav si está disponible; webm como fallback (ambos entiende whisper)
+    function getBestMimeType() {
+      const candidates = ["audio/wav", "audio/webm;codecs=opus", "audio/webm", "audio/mp4"];
+      return candidates.find(t => MediaRecorder.isTypeSupported(t)) ?? "";
+    }
+
+    function formatClock(ms) {
+      const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+      const minutes = String(Math.floor(totalSeconds / 60)).padStart(2, "0");
+      const seconds = String(totalSeconds % 60).padStart(2, "0");
+      return `${minutes}:${seconds}`;
+    }
+
+    function setMeterLevel(value) {
+      const clamped = Math.max(0, Math.min(100, value));
+      meterFillEl.style.width = `${clamped}%`;
+    }
+
+    function stopMeter() {
+      cancelAnimationFrame(meterFrame);
+      meterFrame = 0;
+      setMeterLevel(0);
+      recordingTimeEl.textContent = "00:00";
+      if (audioSource) {
+        audioSource.disconnect();
+        audioSource = null;
+      }
+      if (analyser) {
+        analyser.disconnect();
+        analyser = null;
+      }
+      if (audioContext) {
+        audioContext.close().catch(() => {});
+        audioContext = null;
+      }
+      stream = null;
+    }
+
+    function startMeter() {
+      if (!stream) return;
+      audioContext = new (window.AudioContext || window.webkitAudioContext)();
+      analyser = audioContext.createAnalyser();
+      analyser.fftSize = 256;
+      audioSource = audioContext.createMediaStreamSource(stream);
+      audioSource.connect(analyser);
+
+      const data = new Uint8Array(analyser.frequencyBinCount);
+      const tick = () => {
+        if (!analyser) return;
+        analyser.getByteFrequencyData(data);
+        let total = 0;
+        for (const n of data) total += n;
+        const average = total / data.length;
+        setMeterLevel((average / 255) * 100);
+        recordingTimeEl.textContent = formatClock(Date.now() - startedAt);
+        meterFrame = requestAnimationFrame(tick);
+      };
+      tick();
+    }
+
+    async function startRecording() {
+      try {
+        stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      } catch {
+        showError("Sin acceso al micrófono. Revisá los permisos del navegador.");
+        return;
+      }
+
+      chunks        = [];
+      const mimeType = getBestMimeType();
+      mediaRecorder = new MediaRecorder(stream, mimeType ? { mimeType } : undefined);
+      mediaRecorder.ondataavailable = e => { if (e.data.size > 0) chunks.push(e.data); };
+      mediaRecorder.start(100);   // chunks cada 100 ms para no perder el último fragmento
+      startedAt = Date.now();
+      lastDurationMs = 0;
+      startMeter();
+      isRecording = true;
+      heardTextEl.textContent = "Grabando tu voz...";
+      sttDebugEl.textContent = "";
+      setState("recording");
+    }
+
+    async function stopRecording() {
+      isRecording = false;
+      setState("thinking");
+      lastDurationMs = Date.now() - startedAt;
+
+      await new Promise(resolve => {
+        mediaRecorder.onstop = resolve;
+        mediaRecorder.stop();
+        mediaRecorder.stream.getTracks().forEach(t => t.stop());
+      });
+      stopMeter();
+
+      const mimeType = mediaRecorder.mimeType || "audio/webm";
+      const ext      = mimeType.includes("mp4") ? "mp4" : mimeType.includes("wav") ? "wav" : "webm";
+      const blob     = new Blob(chunks, { type: mimeType });
+
+      if (blob.size < 4000) {
+        replyEl.textContent = "";
+        statusEl.textContent = "Demasiado corto, intentá de nuevo";
+        heardTextEl.textContent = "No capté suficiente audio.";
+        setTimeout(() => setState("idle"), 2200);
+        return;
+      }
+
+      await processAudio(blob, ext);
+    }
+
+    // ── pipeline: audio → texto → LLM → voz ─────────────────────────────────
+    async function processAudio(blob, ext) {
+      // 1) STT
+      let text = "";
+      try {
+        const audioFile = new File([blob], `audio.${ext}`, { type: blob.type });
+        const r = await client.predict("/transcribe", { audio: audioFile, duration_ms: lastDurationMs });
+        text = r.data?.[0]?.text ?? "";
+        const debug = r.data?.[0]?.debug ?? {};
+        const parts = [];
+        if (typeof debug.duration_s === "number") parts.push(`duración ${debug.duration_s.toFixed(1)}s`);
+        if (typeof debug.language_probability === "number") parts.push(`idioma ${debug.language_probability.toFixed(2)}`);
+        if (typeof debug.avg_logprob === "number") parts.push(`confianza ${debug.avg_logprob.toFixed(2)}`);
+        if (debug.rejected_reason) parts.push(`alerta ${debug.rejected_reason}`);
+        sttDebugEl.textContent = parts.length ? parts.join(" · ") : "";
+      } catch (e) {
+        showError("Error al transcribir el audio.");
+        heardTextEl.textContent = "No pude transcribir el audio.";
+        sttDebugEl.textContent = "";
+        setState("idle");
+        return;
+      }
+
+      if (!text.trim()) {
+        statusEl.textContent = "No te escuché bien, intentá de nuevo";
+        heardTextEl.textContent = "No entendí ninguna palabra clara.";
+        if (!sttDebugEl.textContent) {
+          sttDebugEl.textContent = "Probá hablar más cerca o con frases más cortas.";
+        }
+        setTimeout(() => setState("idle"), 2200);
+        return;
+      }
+
+      heardTextEl.textContent = text;
+      micStateEl.textContent = "Texto detectado";
+
+      // 2) LLM
+      let reply = "";
+      try {
+        const r = await client.predict("/chat", { message: text, child_age: 3 });
+        reply = r.data?.[0]?.reply ?? "";
+      } catch (e) {
+        showError("Error al generar respuesta.");
+        setState("idle");
+        return;
+      }
+
+      replyEl.textContent = reply;
+
+      // 3) TTS
+      let audioUrl = "";
+      try {
+        const r = await client.predict("/speak", { text: reply });
+        // FileData puede venir con .url o con .path (Gradio lo resuelve según versión)
+        const fd = r.data?.[0];
+        audioUrl = fd?.url ?? fd?.path ?? "";
+      } catch (e) {
+        // Si TTS falla igual se muestra el texto
+        setState("idle");
+        return;
+      }
+
+      // 4) Reproducir
+      if (audioUrl) {
+        setState("speaking");
+        const audio = new Audio(audioUrl);
+        audio.onended = () => setState("idle");
+        audio.onerror = () => setState("idle");
+        audio.play().catch(() => setState("idle"));
+      } else {
+        setState("idle");
+      }
+    }
+
+    // ── evento del botón ─────────────────────────────────────────────────────
+    btn.addEventListener("click", () => {
+      if (btn.classList.contains("locked")) return;
+      if (isRecording) stopRecording();
+      else             startRecording();
+    });
+
+    setState("idle");
+    heardTextEl.textContent = "Esperando tu respuesta...";
+    await startSession();
+  </script>
+</body>
+</html>

llm/engine.py

@@ -0,0 +1,207 @@
+"""
+Motor conversacional. El LLM NUNCA es la fuente de la verdad:
+  - decide la intención (charlar / contar / formas / colores / animales / cuento)
+  - si hay una actividad o cuento, los TEXTOS salen de `content/` (curados),
+    el modelo solo los presenta con calidez y maneja el turno.
+
+Runtime: llama.cpp vía llama-cpp-python (GGUF, chat_format="chatml"), 100% local.
+"""
+
+import ctypes
+import os
+import sysconfig
+
+
+def _preload_cuda_libs() -> None:
+    """Dev local con GPU: el wheel CUDA de llama-cpp-python necesita poder
+    resolver libcudart/libcublas. Si los paquetes nvidia-cuda-runtime-cu12 /
+    nvidia-cublas-cu12 están instalados los precargamos; si no (build
+    CPU-only, como en el HF Space), no hace falta y no pasa nada."""
+    site_packages = sysconfig.get_paths()["purelib"]
+    for rel in ("nvidia/cuda_runtime/lib/libcudart.so.12", "nvidia/cublas/lib/libcublas.so.12"):
+        path = os.path.join(site_packages, rel)
+        if os.path.exists(path):
+            ctypes.CDLL(path, mode=ctypes.RTLD_GLOBAL)
+
+
+_preload_cuda_libs()
+
+from llama_cpp import Llama
+
+SYSTEM_PROMPT = """Eres Lumi, un amigo de juego cálido y paciente para una niña de unos 3 años.
+Reglas que SIEMPRE cumples:
+- Hablas en español latinoamericano neutro, con frases MUY cortas y simples (máximo dos oraciones).
+- Tono dulce, alegre y alentador. Celebras cada intento ("¡muy bien!", "¡qué lindo!").
+- NUNCA inventas datos, cuentos ni números. Si hace falta contenido (un cuento, una
+  cuenta, una figura), usas SOLO el texto que te pasa el sistema entre <contenido>...</contenido>.
+- Si el sistema te pasa un bloque <contexto>...</contexto>, son datos reales sobre lo que
+  ya vivieron juntos (para sonar cercana, ej. "¡como el cuento que te conté el otro día!").
+  Úsalo solo para el tono cálido: NUNCA inventes detalles nuevos a partir de él.
+- Si no sabes algo o no tienes contenido, lo dices simple y propones un juego: no inventas.
+- Nunca hablas de temas adultos, miedos, violencia ni nada inapropiado. Rediriges con cariño.
+- Una pregunta por vez. Esperas la respuesta de la niña.
+"""
+
+INTENT_LABELS = {
+    "story":    "los cuentos",
+    "counting": "contar",
+    "shapes":   "las formas",
+    "colors":   "los colores",
+    "animals":  "los animales",
+    "song":     "las canciones",
+    "emotion":  "hablar de emociones",
+}
+
+OPENING_INTENTS = (
+    "counting",
+    "colors",
+    "animals",
+    "story",
+    "shapes",
+    "song",
+    "emotion",
+)
+
+POSITIVE_CUES = ("bien", "genial", "contenta", "contento", "feliz", "alegre", "sí", "si")
+NEGATIVE_CUES = ("mal", "triste", "cansada", "cansado", "enojada", "enojado", "no")
+
+
+class LumiEngine:
+    def __init__(self, model_path: str, content, store=None, n_ctx: int = 4096, n_gpu_layers: int | None = None):
+        self.content = content
+        self.store   = store
+        if n_gpu_layers is None:
+            # -1 = todas las capas en GPU (dev local). En el Space: LUMI_N_GPU_LAYERS=0 (CPU-only).
+            n_gpu_layers = int(os.environ.get("LUMI_N_GPU_LAYERS", "-1"))
+        self.llm = Llama(
+            model_path=model_path,
+            chat_format="chatml",
+            n_ctx=n_ctx,
+            n_gpu_layers=n_gpu_layers,
+            verbose=False,
+        )
+
+    def _intent(self, message: str) -> str:
+        m = message.lower()
+        if any(w in m for w in ("cuento", "cuentito", "historia")):
+            return "story"
+        if any(w in m for w in ("contar", "número", "numero", "cuántos", "cuantos")):
+            return "counting"
+        if any(w in m for w in ("forma", "figura", "círculo", "circulo", "cuadrado", "triángulo", "triangulo")):
+            return "shapes"
+        if any(w in m for w in ("color", "colores")):
+            return "colors"
+        if any(w in m for w in ("animal", "animales", "perro", "gato", "vaca")):
+            return "animals"
+        if any(w in m for w in ("canción", "cancion", "canta", "cantar", "rima")):
+            return "song"
+        if any(w in m for w in ("emoción", "emocion", "siento", "sentir", "contenta", "contento", "triste", "enojada", "enojado")):
+            return "emotion"
+        return "chat"
+
+    def _context_block(self, child_age: int) -> str:
+        if not self.store:
+            return ""
+        return self.store.memory_block(child_age, limit=3)
+
+    def _opening_options(self, child_age: int, limit: int = 3):
+        seen = self.store.seen_ids(child_age) if self.store else set()
+        used_ids = set(seen or set())
+        picked = []
+
+        for intent in OPENING_INTENTS:
+            if len(picked) >= limit:
+                break
+            activity = self.content.pick(intent, child_age, exclude_ids=used_ids)
+            if activity and activity["id"] not in used_ids:
+                picked.append(activity)
+                used_ids.add(activity["id"])
+
+        if len(picked) < limit:
+            for items in self.content.items.values():
+                for activity in items:
+                    if len(picked) >= limit:
+                        break
+                    if activity["id"] in used_ids:
+                        continue
+                    if not (activity.get("min_age", 0) <= child_age <= activity.get("max_age", 99)):
+                        continue
+                    picked.append(activity)
+                    used_ids.add(activity["id"])
+                if len(picked) >= limit:
+                    break
+
+        return picked
+
+    @staticmethod
+    def _format_opening_options(options) -> str:
+        titles = [opt["title"].lower() for opt in options if opt.get("title")]
+        if not titles:
+            return "un cuento, contar o jugar con colores"
+        if len(titles) == 1:
+            return titles[0]
+        if len(titles) == 2:
+            return f"{titles[0]} o {titles[1]}"
+        return f"{titles[0]}, {titles[1]} o {titles[2]}"
+
+    def opening_prompt(self, child_age: int, child_name: str = "") -> dict:
+        options = self._opening_options(child_age, limit=3)
+        name = child_name.strip()
+        greet = f"Hola{', ' + name if name else ''}. ¿Cómo estás hoy?"
+        options_text = self._format_opening_options(options)
+        reply = f"{greet} Hoy podemos hacer {options_text}. ¿Qué tenés ganas de hacer?"
+        return {"reply": reply, "options": options}
+
+    def after_mood_prompt(self, message: str, child_age: int) -> dict:
+        m = message.lower()
+        if any(word in m for word in POSITIVE_CUES):
+            prefix = "Qué bueno"
+        elif any(word in m for word in NEGATIVE_CUES):
+            prefix = "Te acompaño"
+        else:
+            prefix = "Gracias por contarme"
+
+        options = self._opening_options(child_age, limit=3)
+        options_text = self._format_opening_options(options)
+        reply = f"{prefix}. Hoy podemos hacer {options_text}. ¿Qué tenés ganas de hacer?"
+        return {"reply": reply, "options": options}
+
+    def _history_messages(self, child_age: int, limit: int = 3) -> list[dict]:
+        """Últimos turnos reales (user/assistant) de esta conversación, para que
+        el modelo mantenga el hilo (referencias, tono) además del resumen que
+        da `_context_block`."""
+        if not self.store:
+            return []
+        turns = self.store.recent_turns(child_age, limit=limit)
+        messages: list[dict] = []
+        for turn in reversed(turns):
+            if turn["blocked"] or not turn["message"] or not turn["reply"]:
+                continue
+            messages.append({"role": "user", "content": turn["message"]})
+            messages.append({"role": "assistant", "content": turn["reply"]})
+        return messages
+
+    def respond(self, message: str, child_age: int = 3):
+        intent   = self._intent(message)
+        activity = None
+        content_block = ""
+
+        if intent != "chat":
+            seen = self.store.seen_ids(child_age) if self.store else None
+            activity = self.content.pick(intent, child_age, exclude_ids=seen)
+            if activity:
+                content_block = f"\n<contenido>\n{activity['script']}\n</contenido>\n"
+                if self.store:
+                    self.store.mark_seen(child_age, activity["id"], intent, activity.get("title"))
+
+        context_block = self._context_block(child_age)
+        user_turn = message + content_block + context_block
+
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            *self._history_messages(child_age),
+            {"role": "user", "content": user_turn},
+        ]
+        resp  = self.llm.create_chat_completion(messages=messages, max_tokens=120, temperature=0.6)
+        reply = resp["choices"][0]["message"]["content"].strip()
+        return reply, activity

parental/store.py

@@ -0,0 +1,429 @@
+"""
+Memoria local de Lumi basada en SQLite.
+
+Usos principales:
+- panel parental: ver turnos, actividades y señales de preferencia
+- memoria de conversación: seguir el hilo reciente
+- memoria de contenido: evitar repetir siempre lo mismo
+- estado corto de sesión: saber qué actividad estaba abierta
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from typing import Any
+
+
+class ParentalStore:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        con = self._con()
+        self._ensure_schema(con)
+        con.commit()
+        con.close()
+
+    def _con(self):
+        con = sqlite3.connect(self.db_path)
+        con.row_factory = sqlite3.Row
+        return con
+
+    def _ensure_schema(self, con):
+        con.execute(
+            """CREATE TABLE IF NOT EXISTS log (
+                   id INTEGER PRIMARY KEY AUTOINCREMENT,
+                   ts REAL,
+                   child_age INTEGER,
+                   message TEXT,
+                   reply TEXT,
+                   blocked INTEGER)"""
+        )
+        con.execute(
+            """CREATE TABLE IF NOT EXISTS seen_content (
+                   id INTEGER PRIMARY KEY AUTOINCREMENT,
+                   ts REAL,
+                   child_age INTEGER,
+                   content_id TEXT,
+                   intent TEXT,
+                   title TEXT)"""
+        )
+        con.execute(
+            """CREATE TABLE IF NOT EXISTS session_state (
+                   child_age INTEGER PRIMARY KEY,
+                   active_content_id TEXT,
+                   active_intent TEXT,
+                   active_title TEXT,
+                   active_step TEXT,
+                   last_user_text TEXT,
+                   last_reply TEXT,
+                   last_ts REAL,
+                   meta_json TEXT)"""
+        )
+        con.execute(
+            """CREATE TABLE IF NOT EXISTS activity_events (
+                   id INTEGER PRIMARY KEY AUTOINCREMENT,
+                   ts REAL,
+                   child_age INTEGER,
+                   content_id TEXT,
+                   intent TEXT,
+                   title TEXT,
+                   status TEXT,
+                   user_text TEXT,
+                   reply_text TEXT,
+                   extra_json TEXT)"""
+        )
+        cols = {row["name"] for row in con.execute("PRAGMA table_info(seen_content)").fetchall()}
+        if "title" not in cols:
+            con.execute("ALTER TABLE seen_content ADD COLUMN title TEXT")
+
+    def _ensure_session_row(self, con, child_age: int):
+        con.execute(
+            "INSERT OR IGNORE INTO session_state (child_age, last_ts, meta_json) VALUES (?, ?, ?)",
+            (child_age, time.time(), "{}"),
+        )
+
+    def _load_session(self, con, child_age: int) -> dict[str, Any]:
+        self._ensure_session_row(con, child_age)
+        row = con.execute(
+            "SELECT * FROM session_state WHERE child_age=?",
+            (child_age,),
+        ).fetchone()
+        if not row:
+            return {}
+        data = dict(row)
+        meta = data.get("meta_json") or "{}"
+        try:
+            data["meta"] = json.loads(meta)
+        except json.JSONDecodeError:
+            data["meta"] = {}
+        return data
+
+    def _save_session(self, con, child_age: int, updates: dict[str, Any]):
+        current = self._load_session(con, child_age)
+        meta = dict(current.get("meta", {}))
+        if "meta" in updates:
+            meta.update(updates.pop("meta") or {})
+        current.update(updates)
+        current["meta"] = meta
+        con.execute(
+            """INSERT INTO session_state (
+                   child_age, active_content_id, active_intent, active_title, active_step,
+                   last_user_text, last_reply, last_ts, meta_json
+               ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+               ON CONFLICT(child_age) DO UPDATE SET
+                   active_content_id=excluded.active_content_id,
+                   active_intent=excluded.active_intent,
+                   active_title=excluded.active_title,
+                   active_step=excluded.active_step,
+                   last_user_text=excluded.last_user_text,
+                   last_reply=excluded.last_reply,
+                   last_ts=excluded.last_ts,
+                   meta_json=excluded.meta_json""",
+            (
+                child_age,
+                current.get("active_content_id"),
+                current.get("active_intent"),
+                current.get("active_title"),
+                current.get("active_step"),
+                current.get("last_user_text"),
+                current.get("last_reply"),
+                current.get("last_ts", time.time()),
+                json.dumps(current.get("meta", {}), ensure_ascii=False),
+            ),
+        )
+
+    def start_session(self, child_age: int, child_name: str = ""):
+        """Abre una sesión nueva o reinicia el estado corto de la sesión."""
+        con = self._con()
+        now = time.time()
+        self._save_session(
+            con,
+            child_age,
+            {
+                "active_content_id": None,
+                "active_intent": None,
+                "active_title": None,
+                "active_step": "intro",
+                "last_user_text": None,
+                "last_reply": None,
+                "last_ts": now,
+                "meta": {
+                    "phase": "awaiting_mood",
+                    "child_name": child_name.strip(),
+                    "started_at": now,
+                    "intro_sent_at": now,
+                },
+            },
+        )
+        con.commit()
+        con.close()
+
+    def session_phase(self, child_age: int) -> str:
+        con = self._con()
+        session = self._load_session(con, child_age)
+        con.close()
+        return (session.get("meta") or {}).get("phase", "ready")
+
+    def set_session_phase(self, child_age: int, phase: str):
+        con = self._con()
+        session = self._load_session(con, child_age)
+        meta = dict(session.get("meta", {}))
+        meta["phase"] = phase
+        self._save_session(
+            con,
+            child_age,
+            {
+                "active_content_id": session.get("active_content_id"),
+                "active_intent": session.get("active_intent"),
+                "active_title": session.get("active_title"),
+                "active_step": session.get("active_step"),
+                "last_user_text": session.get("last_user_text"),
+                "last_reply": session.get("last_reply"),
+                "last_ts": session.get("last_ts", time.time()),
+                "meta": meta,
+            },
+        )
+        con.commit()
+        con.close()
+
+    def session_child_name(self, child_age: int) -> str:
+        con = self._con()
+        session = self._load_session(con, child_age)
+        con.close()
+        return (session.get("meta") or {}).get("child_name", "")
+
+    def log(self, child_age, message, reply, blocked=False, activity=None):
+        self.record_turn(child_age, message, reply, blocked=blocked, activity=activity)
+
+    def record_turn(self, child_age: int, message: str, reply: str, blocked: bool = False, activity: dict | None = None):
+        """Guarda el turno y actualiza la memoria corta.
+
+        Si había una actividad activa y llega otro turno, la cerramos como
+        "answered" para no dejar el hilo colgado.
+        """
+        now = time.time()
+        con = self._con()
+        session = self._load_session(con, child_age)
+        active_content_id = session.get("active_content_id")
+        active_intent = session.get("active_intent")
+        active_title = session.get("active_title")
+
+        con.execute(
+            "INSERT INTO log (ts, child_age, message, reply, blocked) VALUES (?,?,?,?,?)",
+            (now, child_age, message, reply, int(blocked)),
+        )
+
+        if active_content_id and not blocked and activity is None and message.strip():
+            con.execute(
+                """INSERT INTO activity_events
+                   (ts, child_age, content_id, intent, title, status, user_text, reply_text, extra_json)
+                   VALUES (?,?,?,?,?,?,?,?,?)""",
+                (
+                    now,
+                    child_age,
+                    active_content_id,
+                    active_intent,
+                    active_title,
+                    "answered",
+                    message,
+                    reply,
+                    json.dumps({}, ensure_ascii=False),
+                ),
+            )
+            active_content_id = None
+            active_intent = None
+            active_title = None
+            session["active_step"] = None
+
+        if activity:
+            extra = {
+                "script": activity.get("script"),
+                "min_age": activity.get("min_age"),
+                "max_age": activity.get("max_age"),
+            }
+            con.execute(
+                """INSERT INTO activity_events
+                   (ts, child_age, content_id, intent, title, status, user_text, reply_text, extra_json)
+                   VALUES (?,?,?,?,?,?,?,?,?)""",
+                (
+                    now,
+                    child_age,
+                    activity.get("id"),
+                    activity.get("intent"),
+                    activity.get("title"),
+                    "presented",
+                    message,
+                    reply,
+                    json.dumps(extra, ensure_ascii=False),
+                ),
+            )
+            active_content_id = activity.get("id")
+            active_intent = activity.get("intent")
+            active_title = activity.get("title")
+            session["active_step"] = "presented"
+
+        self._save_session(
+            con,
+            child_age,
+            {
+                "active_content_id": active_content_id,
+                "active_intent": active_intent,
+                "active_title": active_title,
+                "last_user_text": message,
+                "last_reply": reply,
+                "last_ts": now,
+                "meta": session.get("meta", {}),
+            },
+        )
+        con.commit()
+        con.close()
+
+    def mark_seen(self, child_age, content_id, intent, title=None):
+        """Registra que Lumi ya presentó este contenido.
+
+        Sirve para no repetir siempre lo mismo y para derivar intereses.
+        """
+        con = self._con()
+        con.execute(
+            "INSERT INTO seen_content (ts, child_age, content_id, intent, title) VALUES (?,?,?,?,?)",
+            (time.time(), child_age, content_id, intent, title),
+        )
+        con.commit()
+        con.close()
+
+    def seen_ids(self, child_age, since_days=14):
+        cutoff = time.time() - since_days * 86400
+        con = self._con()
+        rows = con.execute(
+            "SELECT DISTINCT content_id FROM seen_content WHERE child_age=? AND ts >= ?",
+            (child_age, cutoff),
+        ).fetchall()
+        con.close()
+        return {r["content_id"] for r in rows}
+
+    def top_intents(self, child_age, since_days=14, limit=3):
+        cutoff = time.time() - since_days * 86400
+        con = self._con()
+        rows = con.execute(
+            """SELECT intent, COUNT(*) as veces FROM seen_content
+               WHERE child_age=? AND ts >= ? AND intent IS NOT NULL
+               GROUP BY intent ORDER BY veces DESC LIMIT ?""",
+            (child_age, cutoff, limit),
+        ).fetchall()
+        con.close()
+        return [(r["intent"], r["veces"]) for r in rows]
+
+    def recent_titles(self, child_age, limit=3):
+        con = self._con()
+        rows = con.execute(
+            """SELECT content_id, title FROM seen_content
+               WHERE child_age=? ORDER BY id DESC LIMIT ?""",
+            (child_age, limit),
+        ).fetchall()
+        con.close()
+        return [r["title"] or r["content_id"] for r in rows]
+
+    def recent_turns(self, child_age, limit=3):
+        con = self._con()
+        rows = con.execute(
+            """SELECT ts, message, reply, blocked FROM log
+               WHERE child_age=? ORDER BY id DESC LIMIT ?""",
+            (child_age, limit),
+        ).fetchall()
+        con.close()
+        return [
+            {
+                "ts": r["ts"],
+                "message": r["message"],
+                "reply": r["reply"],
+                "blocked": bool(r["blocked"]),
+            }
+            for r in rows
+        ]
+
+    def recent_activities(self, child_age, limit=5):
+        con = self._con()
+        rows = con.execute(
+            """SELECT ts, content_id, intent, title, status, user_text, reply_text
+               FROM activity_events
+               WHERE child_age=? ORDER BY id DESC LIMIT ?""",
+            (child_age, limit),
+        ).fetchall()
+        con.close()
+        return [
+            {
+                "ts": r["ts"],
+                "content_id": r["content_id"],
+                "intent": r["intent"],
+                "title": r["title"],
+                "status": r["status"],
+                "user_text": r["user_text"],
+                "reply_text": r["reply_text"],
+            }
+            for r in rows
+        ]
+
+    def session_state(self, child_age):
+        con = self._con()
+        data = self._load_session(con, child_age)
+        con.close()
+        return data
+
+    def memory_snapshot(self, child_age, limit=3):
+        session = self.session_state(child_age)
+        top_intents = self.top_intents(child_age, limit=limit)
+        recent_titles = self.recent_titles(child_age, limit=limit)
+        recent_turns = self.recent_turns(child_age, limit=limit)
+        recent_activities = self.recent_activities(child_age, limit=limit)
+        return {
+            "session": session,
+            "top_intents": top_intents,
+            "recent_titles": recent_titles,
+            "recent_turns": recent_turns,
+            "recent_activities": recent_activities,
+        }
+
+    def memory_block(self, child_age, limit=3):
+        snapshot = self.memory_snapshot(child_age, limit=limit)
+        lines = []
+        phase = (snapshot["session"].get("meta") or {}).get("phase")
+        child_name = (snapshot["session"].get("meta") or {}).get("child_name")
+
+        if child_name:
+            lines.append(f"Sesión de {child_name}.")
+        if phase:
+            lines.append(f"Fase actual: {phase}.")
+
+        active_title = snapshot["session"].get("active_title")
+        if active_title:
+            lines.append(f"Actividad abierta ahora: {active_title}.")
+
+        if snapshot["top_intents"]:
+            favs = ", ".join(f"{intent} ({count})" for intent, count in snapshot["top_intents"])
+            lines.append(f"Lo que más apareció últimamente: {favs}.")
+
+        if snapshot["recent_titles"]:
+            lines.append("Últimas actividades: " + ", ".join(f'"{title}"' for title in snapshot["recent_titles"]) + ".")
+
+        if not lines:
+            return ""
+        return "\n<contexto>\n" + " ".join(lines) + "\n</contexto>\n"
+
+    def recent(self, limit=50):
+        con = self._con()
+        rows = con.execute(
+            "SELECT ts, child_age, message, reply, blocked FROM log ORDER BY id DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+        con.close()
+        return [
+            {
+                "ts": r["ts"],
+                "child_age": r["child_age"],
+                "message": r["message"],
+                "reply": r["reply"],
+                "blocked": bool(r["blocked"]),
+            }
+            for r in rows
+        ]

requirements.txt

@@ -0,0 +1,13 @@
+gradio>=5
+llama-cpp-python
+faster-whisper
+kokoro
+soundfile
+numpy
+
+# Dev local con GPU (opcional, no se usa en el HF Space que corre CPU-only):
+#   pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124
+#   pip install nvidia-cuda-runtime-cu12 nvidia-cublas-cu12
+
+# Para fine-tune (en otra máquina/entorno, no en el Space):
+#   transformers, peft, trl, bitsandbytes, datasets

safety/blocklist.txt

@@ -0,0 +1,59 @@
+# Un término prohibido por línea. Editable por los padres desde el panel.
+# Lista de partida pensada para una nena de ~3 años: violencia, armas,
+# contenido adulto, drogas/alcohol y autolesión. Agregá/quitá lo que quieras.
+
+# Violencia / miedo
+muerte
+morir
+matar
+mataron
+sangre
+herida
+pelea
+golpear
+golpe
+disparar
+bala
+violencia
+asesino
+secuestro
+
+# Armas
+arma
+armas
+pistola
+cuchillo
+espada
+bomba
+
+# Contenido adulto
+sexo
+sexual
+desnudo
+desnuda
+porno
+violación
+
+# Drogas / alcohol
+droga
+drogas
+alcohol
+cerveza
+borracho
+cigarrillo
+fumar
+
+# Autolesión
+suicidio
+suicidarse
+lastimarse
+
+# Lenguaje fuerte
+puta
+puto
+mierda
+carajo
+pendejo
+idiota
+estúpido
+estúpida

safety/guard.py

@@ -0,0 +1,33 @@
+"""
+Capa de seguridad simple pero real. Defensa en profundidad:
+  - blocks_input  : el niño/entorno trae un tema prohibido -> redirigimos.
+  - blocks_output : red de seguridad sobre lo que sale del LLM.
+La blocklist la editan los padres desde el panel parental (un término por línea).
+Para producción conviene sumar un clasificador, pero esto cubre el MVP.
+"""
+
+import os
+
+
+class SafetyGuard:
+    def __init__(self, blocklist_path: str):
+        self.terms = []
+        if os.path.exists(blocklist_path):
+            with open(blocklist_path, encoding="utf-8") as f:
+                self.terms = [t.strip().lower() for t in f if t.strip() and not t.startswith("#")]
+
+    def _hit(self, text: str) -> bool:
+        t = text.lower()
+        return any(term in t for term in self.terms)
+
+    def blocks_input(self, message: str) -> bool:
+        return self._hit(message)
+
+    def blocks_output(self, reply: str) -> bool:
+        return self._hit(reply)
+
+    def gentle_redirect(self) -> str:
+        return "Mmm, mejor juguemos a otra cosa. ¿Querés que contemos o que te cuente un cuentito?"
+
+    def safe_fallback(self) -> str:
+        return "Uy, me perdí un poquito. ¿Jugamos a contar?"

voice/stt.py

@@ -0,0 +1,96 @@
+"""
+STT con faster-whisper (local, push-to-talk).
+Mismas advertencias que antes: ASR rinde MAL con voz de niños de 3 años;
+push-to-talk + language='es' ayudan.
+"""
+
+from __future__ import annotations
+
+from statistics import mean
+
+from faster_whisper import WhisperModel
+
+_model: WhisperModel | None = None
+
+
+def _get_model() -> WhisperModel:
+    global _model
+    if _model is None:
+        _model = WhisperModel("small", device="cpu", compute_type="int8")
+    return _model
+
+
+def _clean_text(text: str) -> str:
+    return " ".join(text.split()).strip()
+
+
+def transcribe(audio_path: str, duration_ms: int | None = None) -> dict:
+    """
+    Transcribe audio and return diagnostics so the UI can tell apart:
+    - audio too short
+    - no speech detected
+    - low-confidence or suspiciously long hallucinations
+    """
+    segments, info = _get_model().transcribe(
+        audio_path,
+        language="es",
+        beam_size=1,
+        best_of=1,
+        temperature=0.0,
+        condition_on_previous_text=False,
+        vad_filter=True,
+        vad_parameters={"min_silence_duration_ms": 300},
+    )
+
+    texts: list[str] = []
+    segment_logs: list[float] = []
+    no_speech_scores: list[float] = []
+
+    for segment in segments:
+        text = _clean_text(segment.text)
+        if text:
+            texts.append(text)
+        avg_logprob = getattr(segment, "avg_logprob", None)
+        if isinstance(avg_logprob, (int, float)):
+            segment_logs.append(float(avg_logprob))
+        no_speech_prob = getattr(segment, "no_speech_prob", None)
+        if isinstance(no_speech_prob, (int, float)):
+            no_speech_scores.append(float(no_speech_prob))
+
+    text = _clean_text(" ".join(texts))
+    language_probability = float(getattr(info, "language_probability", 0.0) or 0.0)
+    avg_logprob = mean(segment_logs) if segment_logs else None
+    no_speech_prob = max(no_speech_scores) if no_speech_scores else None
+    duration_s = (duration_ms or 0) / 1000.0 if duration_ms is not None else None
+    word_count = len(text.split())
+
+    rejected_reason = None
+    if duration_s is not None:
+        # Heurística anti-alucinación: si el audio fue muy corto pero el texto es largo,
+        # preferimos devolver vacío y pedir otro intento.
+        suspiciously_long = word_count > max(6, int(duration_s * 3) + 2)
+        if suspiciously_long and language_probability < 0.85:
+            rejected_reason = "transcripcion_sospechosa"
+            text = ""
+
+    if not text:
+        if rejected_reason is None:
+            if duration_s is not None and duration_s < 0.7:
+                rejected_reason = "audio_corto"
+            elif no_speech_prob is not None and no_speech_prob > 0.75:
+                rejected_reason = "sin_voz"
+            else:
+                rejected_reason = "sin_texto"
+
+    return {
+        "text": text,
+        "debug": {
+            "language": getattr(info, "language", "es"),
+            "language_probability": round(language_probability, 3),
+            "avg_logprob": round(avg_logprob, 3) if avg_logprob is not None else None,
+            "no_speech_prob": round(no_speech_prob, 3) if no_speech_prob is not None else None,
+            "duration_s": round(duration_s, 3) if duration_s is not None else None,
+            "word_count": word_count,
+            "rejected_reason": rejected_reason,
+        },
+    }

voice/tts.py

@@ -0,0 +1,104 @@
+"""
+TTS local-first para Lumi.
+
+Ruta única:
+- Kokoro en español con una voz femenina más neutra/latina.
+
+Cache:
+- si el texto ya fue sintetizado, reutilizamos `content/audio/<hash>.wav`
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import wave
+
+import numpy as np
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CONTENT_AUDIO_DIR = os.path.join(HERE, "content", "audio")
+
+KOKORO_LANG = "e"
+KOKORO_VOICE = "ef_dora"
+KOKORO_SPEED = 1.0
+
+_pipeline = None
+
+
+def _get_pipeline():
+    global _pipeline
+    if _pipeline is None:
+        from kokoro import KPipeline
+
+        _pipeline = KPipeline(lang_code=KOKORO_LANG)
+    return _pipeline
+
+
+def _ensure_dirs():
+    os.makedirs(CONTENT_AUDIO_DIR, exist_ok=True)
+
+
+def _cache_key(text: str) -> str:
+    payload = f"{KOKORO_LANG}|{KOKORO_VOICE}|{KOKORO_SPEED}|{text.strip()}"
+    return hashlib.sha1(payload.encode("utf-8")).hexdigest()
+
+
+def _cache_path(text: str) -> str:
+    return os.path.join(CONTENT_AUDIO_DIR, f"{_cache_key(text)}.wav")
+
+
+def _write_wav(path: str, audio: np.ndarray, sample_rate: int = 24000) -> str:
+    audio = np.asarray(audio, dtype=np.float32)
+    audio = np.clip(audio, -1.0, 1.0)
+    pcm16 = (audio * 32767).astype(np.int16)
+    with wave.open(path, "wb") as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(2)
+        wav_file.setframerate(sample_rate)
+        wav_file.writeframes(pcm16.tobytes())
+    return path
+
+
+def _synthesize_kokoro(text: str) -> str:
+    pipeline = _get_pipeline()
+    chunks = list(pipeline(text, voice=KOKORO_VOICE, speed=KOKORO_SPEED, split_pattern=r"\n+"))
+    audio_parts = [np.asarray(chunk[2], dtype=np.float32) for chunk in chunks if chunk[2] is not None]
+    if not audio_parts:
+        raise RuntimeError("Kokoro no devolvió audio")
+
+    audio = audio_parts[0]
+    if len(audio_parts) > 1:
+        audio = np.concatenate(audio_parts)
+
+    out_path = _cache_path(text)
+    return _write_wav(out_path, audio, sample_rate=24000)
+
+
+def warmup():
+    """Carga el pipeline de Kokoro al arrancar la app.
+
+    La primera síntesis en un proceso nuevo tarda ~60s (carga de pesos del
+    modelo en CPU); sin esto, esa demora caería sobre la primera respuesta
+    real de la nena.
+    """
+    pipeline = _get_pipeline()
+    list(pipeline("Hola.", voice=KOKORO_VOICE, speed=KOKORO_SPEED, split_pattern=r"\n+"))
+
+
+def synthesize(text: str) -> str:
+    """
+    Devuelve la ruta al audio generado.
+
+    Siempre intenta cache local primero. Si no existe, sintetiza con Kokoro.
+    """
+    _ensure_dirs()
+    text = text.strip()
+    if not text:
+        raise ValueError("No se puede sintetizar texto vacío")
+
+    cached = _cache_path(text)
+    if os.path.exists(cached):
+        return cached
+
+    return _synthesize_kokoro(text)