sdd-es 2.0.0 → 2.6.0

package/commands/sdd.constitucion.md

@@ -71,28 +71,81 @@ find . -maxdepth 3 -type d \
 ls test/ tests/ __tests__/ spec/ 2>/dev/null
 ```
 
-## PASO 3 — Detectar el perfil del usuario
+## PASO 3 — Detectar el perfil del usuario (AUTO-DETECCIÓN)
 
 Antes de recopilar valores, determina el **perfil** con el que se conducirá todo el flujo. Esto cambia el tono y cuánto se le pide al usuario, pero NO cambia el rigor del producto generado.
 
-Pregunta una sola vez (o infiérelo de cómo escribe el usuario):
+**Lógica de detección automática:**
 
-> ¿Cómo prefieres trabajar?
-> **a) Guiado** — no programo (o muy poco). Quiero que tú decidas lo técnico y me expliques en palabras simples. Tú eliges el stack.
-> **b) Experto** — sé programar. Quiero control del stack y de las decisiones técnicas.
+```bash
+# Capturar descripción del usuario (si viene en parámetros o preguntarla)
+USER_INPUT="$(echo "$1" | tr '[:upper:]' '[:lower:]')"
+
+# Palabras clave = "guiado" (usuario describe funcionalidad)
+GUIADO_KEYWORDS="app|web|sitio|herramienta|bot|automatización|tienda|lista|formulario|chat|galería|blog|carrito|perfil|dashboard"
+
+# Palabras clave = "experto" (usuario menciona tecnología)
+EXPERTO_KEYWORDS="react|vue|angular|typescript|node|python|rust|go|java|fastapi|django|postgres|mysql|mongodb|docker|kubernetes|nextjs|nestjs|express"
+
+# Contar coincidencias
+GUIADO_COUNT=$(echo "$USER_INPUT" | grep -io "\(${GUIADO_KEYWORDS}\)" | wc -l)
+EXPERTO_COUNT=$(echo "$USER_INPUT" | grep -io "\(${EXPERTO_KEYWORDS}\)" | wc -l)
+
+# Decisión
+if [ $GUIADO_COUNT -gt 0 ] && [ $EXPERTO_COUNT -eq 0 ]; then
+  PERFIL="guiado"
+elif [ $EXPERTO_COUNT -gt 0 ] && [ $GUIADO_COUNT -le 1 ]; then
+  PERFIL="experto"
+elif [ $EXPERTO_COUNT -gt 0 ] && [ $GUIADO_COUNT -gt 0 ]; then
+  # Perfil mixto: preguntar explícitamente
+  PERFIL="mixto"
+  echo "📋 Veo que tienes ideas técnicas además de funcionales."
+  echo "¿Prefieres modo EXPERTO (controlas las decisiones técnicas)"
+  echo "o modo GUIADO (yo las decido por ti, solo confirmas pasos)?"
+  read PERFIL_CHOICE
+  [ "$PERFIL_CHOICE" = "experto" ] && PERFIL="experto" || PERFIL="guiado"
+else
+  # Default ante la duda
+  PERFIL="guiado"
+fi
+
+echo "✅ PERFIL DETECTADO: $PERFIL"
+```
+
+**Ejemplos de detección:**
 
-Reglas de inferencia (si el usuario no responde explícitamente):
-- Señales de **guiado**: "no sé programar", "quiero una app/herramienta que…", describe el producto por su función y no por su tecnología, pide que "lo hagas tú".
-- Señales de **experto**: menciona lenguajes/frameworks/BD concretos, pide control de arquitectura, usa jerga técnica.
-- Ante la duda → **guiado** (es el modo más seguro: explica más y confirma antes de actuar).
+| Input usuario | Palabras clave | Perfil |
+|---------------|----------------|--------|
+| "una tienda donde vendo productos" | app, tienda (guiado) | **guiado** |
+| "React + Node + MongoDB" | react, node, mongodb (experto) | **experto** |
+| "app de chat con Python" | app (guiado) + python (experto) | **mixto** → preguntar |
+| "necesito un bot que alertas" | bot (guiado) | **guiado** |
+| "un formulario en Next.js" | formulario (guiado) + nextjs (experto) | **mixto** → preguntar |
 
 **En perfil `guiado`:**
-- El stack se **recomienda automáticamente** según el tipo de producto. NO obligues al usuario a elegir tecnología. Defaults sensatos:
-  - "app web" / "página" / "sitio" → Node + Vite + SQLite
-  - "API" / "backend" / "servicio" → Node + Express + SQLite
-  - "bot" / "automatización" / "script" → Python
-  - "herramienta para Claude / asistente / integración" → servidor MCP en Node (ver `/sdd.crear-mcp`)
-  - Si no encaja, elige el más simple que cumpla y **explica en una frase por qué**.
+
+El stack se **elige automáticamente** según lo que el usuario quiere construir. Aquí está el proceso:
+
+1. El usuario describe su idea EN PALABRAS SIMPLES:
+   - Ejemplos válidos:
+     - "una tienda online donde vendo mis productos artesanales"
+     - "una app para que mi equipo de 5 personas coordine tareas diarias"
+     - "un bot que me avise cuando alguien menciona mi marca en redes sociales"
+     - "una comunidad online donde mis clientes comparten fotos de sus compras"
+   
+2. Recomendarás el stack AUTOMÁTICAMENTE sin que el usuario tenga que elegir. Usa estos defaults sensatos:
+   - "app web" / "página" / "sitio" → Node + Vite + SQLite
+   - "API" / "backend" / "servicio" → Node + Express + SQLite
+   - "bot" / "automatización" / "script" → Python
+   - "herramienta para Claude / asistente / integración" → servidor MCP en Node (ver `/sdd.crear-mcp`)
+   - Si no encaja exactamente, elige el más simple que cumpla.
+
+3. **Explicar la recomendación en lenguaje simple**, no técnico. Ejemplo:
+   - ❌ "Detectado: Node.js + Express + PostgreSQL"
+   - ✅ "Para tu tienda online, recomiendo: JavaScript (es el lenguaje más accesible para empezar), SQLite para guardar productos y pedidos (es gratis, confiable y no necesita instalar nada extra), y Node.js en el servidor (es lo más rápido para tener algo funcionando)."
+   
+4. Preguntar de forma amigable: "¿Te parece bien? ¿Hay algo que quieras cambiar?"
+
 - Activa la skill `modo-guiado` para el resto de la conversación (lenguaje sin jerga, confirmar antes de actuar, nunca pedir que edite archivos a mano).
 
 **En perfil `experto`:** sigue el flujo técnico normal (el usuario define o confirma el stack).
@@ -106,11 +159,11 @@ Si la constitución **NO existe**, conduce una conversación corta y eficiente.
 Preguntas obligatorias (haz una a la vez, o agrupadas):
 
 1. **Propósito**: ¿Cuál es el propósito del proyecto en 1-2 frases?
-2. **Audiencia**: ¿Quién consume esto? (equipo interno, usuarios externos, otro servicio)
+2. **Audiencia**: ¿Quién usa esto? (equipo interno, clientes, otros desarrolladores, etc.)
 3. **No-negociables**: ¿Qué estándares son innegociables? (tests obligatorios, sin warnings, tipado estricto, etc.)
 4. **Restricciones**: ¿Hay algo que NUNCA hay que hacer en este proyecto? (no agregar dependencias sin justificación, no romper API pública, etc.)
 
-> **En perfil `guiado`**, NO hagas las preguntas 3 y 4 con jerga técnica. En su lugar fija defaults profesionales por debajo (tests obligatorios, lint estricto, sin secretos en el código) y solo confirma el propósito y para quién es. Aplicas los estándares altos sin cargarle la decisión al usuario.
+> **En perfil `guiado`**, NO hagas las preguntas 3 y 4 con jerga técnica. En su lugar fija defaults profesionales por debajo (tests obligatorios, lint estricto, sin secretos en el código) y solo confirma el propósito y para quién es. Aplicas los estándares altos sin cargarle la decisión al usuario. Si dice algo como "no entiendo", "explícame", o "no sé qué significa eso", **pausa inmediatamente**, explica con una analogía simple del mundo real (ve la Regla 7 en `skills/modo-guiado/SKILL.md`), y continúa.
 
 Si la constitución **YA existe**, lee los placeholders pendientes y pregunta solo por esos. Determina el tipo de cambio para el versionado:
 
@@ -120,7 +173,129 @@ Si la constitución **YA existe**, lee los placeholders pendientes y pregunta so
 
 Propón el incremento de versión y muestra el razonamiento.
 
-## PASO 4 — Generar la constitución
+## PASO 4 — GitHub (solo si perfil == guiado)
+
+**Solo en perfil `guiado`**, ofrecer de forma amigable guardar el proyecto en GitHub:
+
+> ¿Quieres guardar tu proyecto en GitHub? Es como una nube para el código: gratis, seguro, y todos los desarrolladores lo usan. Si no ahora, puedes hacerlo después.
+
+**Si el usuario responde que sí:**
+
+```bash
+# PASO 4.1: Explicar token de forma amigable
+echo "✅ Perfecto. Necesito un token de GitHub."
+echo ""
+echo "Es como una contraseña especial que te da permisos sin usar tu contraseña real."
+echo "Te muestro cómo generarlo en 2 pasos muy rápidos:"
+echo ""
+echo "1. Ve a: https://github.com/settings/tokens?type=pat"
+echo "2. Haz clic en 'Generate new token' → escoge 'Fine-grained tokens'"
+echo "3. Dale permiso: 'repo' (acceso completo a repositorio)"
+echo "4. Copia el token y pégalo aquí"
+echo ""
+read -p "Pega tu token: " GITHUB_TOKEN
+
+# PASO 4.2: Invocar skill github-connect
+echo "⏳ Creando repositorio en GitHub..."
+
+# Guardar token en variable de entorno para la skill
+export GITHUB_TOKEN="$GITHUB_TOKEN"
+
+# Invocar skill github-connect (que maneja toda la creación + push)
+bash "$(dirname "$0")/../skills/github-connect/github-connect.sh" \
+  --repo-name "$(basename "$(pwd)")" \
+  --repo-description "Proyecto SDD-ES: $(cat .sdd/memoria/constitucion.md | head -1)" \
+  --profile "guiado"
+
+if [ $? -eq 0 ]; then
+  # Guardar URL en config
+  REPO_URL=$(gh repo view --json url -q .url 2>/dev/null)
+  echo "git.remote_url: $REPO_URL" >> .sdd/sdd.config.yaml
+  
+  echo ""
+  echo "✅ Tu proyecto está guardado en GitHub:"
+  echo "   $REPO_URL"
+  echo ""
+  echo "Desde ahora, cada cambio que hagas se guarda automáticamente allí."
+else
+  echo "⚠️  Hubo un problema creando el repositorio."
+  echo "Puedes hacerlo después ejecutando:"
+  echo "  /sdd.github-connect"
+fi
+```
+
+**Si el usuario responde que no:**
+
+```bash
+echo "✅ No hay problema. Podemos hacerlo más tarde cuando lo necesites."
+echo ""
+echo "Si cambias de idea, ejecuta: /sdd.github-connect"
+```
+
+---
+
+## PASO 4.5 — Vercel Deploy (solo si perfil == guiado)
+
+**Solo en perfil `guiado`**, ofrecer de forma amigable desplegar en Vercel:
+
+> ¿Quieres que tu app esté en internet cuando esté lista? 
+> Vercel es como un servidor en la nube: gratis hasta cierto límite, y tu app estará accesible desde cualquier lugar.
+
+**Si el usuario responde que sí:**
+
+```bash
+echo "✅ Perfecto. Configuraré Vercel para ti."
+echo ""
+echo "Necesito un token de Vercel — es una contraseña especial (igual que GitHub)."
+echo ""
+echo "1. Ve a: https://vercel.com/account/tokens"
+echo "2. Crea un 'Token' nuevo"
+echo "3. Copia y pégalo aquí:"
+echo ""
+read -p "Pega tu token de Vercel: " VERCEL_TOKEN
+
+# Guardar configuración
+echo "deploy.platform: vercel" >> .sdd/sdd.config.yaml
+echo "deploy.vercel_token_provided: true" >> .sdd/sdd.config.yaml
+
+echo ""
+echo "✅ Vercel está configurado."
+echo "Cuando tu app esté lista, te preguntaré antes de publicarla en internet."
+```
+
+**Si el usuario responde que no:**
+
+```bash
+echo "✅ No hay problema. Puedes publicarla después si quieres."
+echo ""
+echo "Si cambias de idea, ejecuta: /sdd.configurar"
+```
+
+---
+
+## PASO 5 — Guardar perfil y configuración persistente
+
+```bash
+# Guardar el perfil detectado en .sdd/sdd.config.yaml
+# para que comandos posteriores lo respeten
+
+echo "perfil: $PERFIL" >> .sdd/sdd.config.yaml
+
+# Guardar en estado.json también
+cat >> .sdd/estado.json << EOF
+{
+  "perfil_detectado": "$PERFIL",
+  "constitucion_completada_timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "constitucion_versión": "1.0.0"
+}
+EOF
+
+echo "✅ Configuración guardada."
+```
+
+---
+
+## PASO 6 — Generar la constitución
 
 Lee la plantilla `plantillas/constitucion.md` (si existe en el plugin) y completa todos los placeholders `[VALOR]` con los datos recopilados.
 
@@ -228,7 +403,7 @@ TODOs diferidos:
 - Las decisiones técnicas no triviales se documentan como ADR en `.sdd/arquitectura/`
 ```
 
-## PASO 5 — Propagación de consistencia
+## PASO 6 — Propagación de consistencia
 
 Después de actualizar la constitución, revisa estos archivos y actualiza si hay desalineación:
 
@@ -242,7 +417,7 @@ grep -l "[principio_modificado]" commands/*.md 2>/dev/null
 
 Genera el **Informe de Impacto de Sincronización** y lo prepende a la constitución como comentario HTML (ver plantilla arriba).
 
-## PASO 6 — Inicializar resto de estructura SDD
+## PASO 7 — Inicializar resto de estructura SDD
 
 ```bash
 # Crear archivos índice si no existen
@@ -277,7 +452,7 @@ EOF
 EOF
 ```
 
-## PASO 6.5 — Persistir el perfil en la configuración
+## PASO 7.5 — Persistir el perfil en la configuración
 
 Escribe el perfil elegido en `.sdd/sdd.config.yaml`. Si la clave `perfil:` no existe, añádela cerca del inicio del archivo; si existe, actualízala.
 
@@ -292,7 +467,7 @@ fi
 
 (Reemplaza `[PERFIL]` por `guiado` o `experto`.)
 
-## PASO 7 — Actualizar estado global
+## PASO 8 — Actualizar estado global
 
 Crea o actualiza `.sdd/estado.json`:
 
@@ -321,7 +496,7 @@ if [ -f ".sdd/hooks/despues_constitucion.sh" ]; then
 fi
 ```
 
-## PASO 8 — Resumen y siguiente paso
+## PASO 9 — Resumen y siguiente paso
 
 Muestra:
 

package/commands/sdd.construir.md

@@ -0,0 +1,210 @@
+---
+description: Pipeline completo de FORGE. Si no hay IR, interpreta primero. Si no hay diseño, diseña. Luego mapea spec → planifica → tareas → implementa. Punto de entrada único para convertir una idea en código.
+allowed-tools: Read, Write, Bash, Agent
+---
+
+# /sdd.construir — Pipeline Completo
+
+**Uso:**
+```
+/sdd.construir
+/sdd.construir --desde-spec    ← salta directo a planificar (si ya hay spec)
+/sdd.construir --solo-spec     ← genera solo la spec, no continúa
+/sdd.construir --forzar        ← ignora checkpoints y vuelve a ejecutar todo
+```
+
+---
+
+## LÓGICA DE ENTRADA
+
+### Verificar estado del proyecto
+
+```bash
+node -e "
+  const fs = require('fs');
+  const estado = JSON.parse(fs.existsSync('.sdd/estado.json') ? fs.readFileSync('.sdd/estado.json', 'utf8') : '{}');
+  console.log(JSON.stringify({
+    tiene_ir: !!estado.ir_generado && fs.existsSync('.sdd/ir.json'),
+    tiene_design: !!estado.product_design_aprobado && fs.existsSync('.sdd/product-design.json'),
+    tiene_spec: !!estado.spec_activa,
+    pipeline_step: estado.pipeline_step || 'inicio'
+  }));
+"
+```
+
+### Árbol de decisión:
+
+```
+¿Tiene IR?
+  NO → invocar /sdd.interpretar
+       [esperar input del usuario]
+       [volver a /sdd.construir después]
+
+  SÍ → ¿Tiene ProductDesign aprobado?
+         NO → invocar /sdd.diseñar
+              [después continúa automáticamente]
+
+         SÍ → PASO 1: Mapear IR + Design → Spec draft
+              PASO 2: /sdd.especificar (con spec draft como base)
+              PASO 3: /sdd.planificar
+              PASO 4: /sdd.tareas
+              PASO 5: /sdd.implementar
+```
+
+---
+
+## PASO 1 — Mapear IR + ProductDesign → Spec Draft
+
+```bash
+# Verificar que tenemos los inputs
+if [ ! -f ".sdd/ir.json" ] || [ ! -f ".sdd/product-design.json" ]; then
+  echo "Error: Falta IR o ProductDesign"
+  exit 1
+fi
+
+# Ejecutar el mapper
+node sdd-lite/core/ir-to-spec-mapper.js
+
+# El mapper genera .sdd/spec-draft.json con:
+# - user_stories[] ← de features.core del IR
+# - functional_requirements[] ← de core_screens del ProductDesign
+# - actors[] ← del IR
+# - non_functional_requirements[]
+# - out_of_scope[]
+```
+
+Mostrar al usuario:
+
+```
+📋 SPEC DRAFT GENERADA
+─────────────────────────────
+[N] historias de usuario (US-001 a US-00N)
+[M] requerimientos funcionales (RF-001 a RF-00M)
+Actores: [lista]
+
+¿Continuar al plan de implementación?
+  ↵ Enter → continuar
+  m → ver spec completa primero
+  e → editar spec antes de continuar
+```
+
+Si `--solo-spec`, terminar aquí y sugerir `/sdd.especificar`.
+
+---
+
+## PASO 2 — Especificación
+
+Invocar `/sdd.especificar` con la spec-draft como base:
+
+```bash
+# El comando especificar lee .sdd/spec-draft.json si existe
+# y lo usa como punto de partida en lugar de empezar de cero
+/sdd.especificar
+```
+
+Después de especificar, la spec queda en `.sdd/` en el formato de sdd-lite.
+
+---
+
+## PASO 3 — Planificar
+
+```bash
+/sdd.planificar
+```
+
+Genera el plan de implementación basado en la spec.
+
+---
+
+## PASO 4 — Crear Tareas
+
+```bash
+/sdd.tareas
+```
+
+Descompone el plan en tareas atómicas implementables.
+
+---
+
+## PASO 5 — Implementar
+
+```bash
+/sdd.implementar
+```
+
+Genera el código base según las tareas.
+
+---
+
+## Progreso visual
+
+Durante la ejecución, muestra el progreso del pipeline:
+
+```
+FORGE PIPELINE — [product.name]
+═══════════════════════════════════════
+  ✅ Idea interpretada (IR v1)
+  ✅ Diseño aprobado (3 pantallas, stack: React + Node.js + SQLite)
+  🔄 Generando spec...
+  ⭕ Plan pendiente
+  ⭕ Tareas pendientes
+  ⭕ Implementación pendiente
+═══════════════════════════════════════
+```
+
+Actualizar `.sdd/estado.json` después de cada paso:
+
+```bash
+node -e "
+  const fs = require('fs');
+  const e = JSON.parse(fs.readFileSync('.sdd/estado.json', 'utf8') || '{}');
+  e.pipeline_step = 'spec'; // o 'plan', 'tasks', 'code', 'done'
+  e.ultima_actualizacion = new Date().toISOString();
+  fs.writeFileSync('.sdd/estado.json', JSON.stringify(e, null, 2));
+"
+```
+
+---
+
+## Al terminar
+
+```
+═══════════════════════════════════════════
+✅ PROYECTO CONSTRUIDO
+═══════════════════════════════════════════
+
+[product.name] está listo.
+
+Lo que se generó:
+  ✅ IR → .sdd/ir.json
+  ✅ Diseño → .sdd/product-design.json
+  ✅ Wireframe → .sdd/diseño/wireframe-pantalla-principal.html
+  ✅ Spec → .sdd/[spec].md
+  ✅ Plan → .sdd/[plan].md
+  ✅ Tareas → .sdd/[tareas].md
+  ✅ Código base → [carpeta del proyecto]
+
+¿Qué sigue?
+  /sdd.implementar     → implementar las tareas pendientes
+  /sdd.exportar        → empaquetar para compartir o desplegar
+  /sdd.estado          → ver el estado completo del proyecto
+```
+
+---
+
+## Manejo de errores
+
+Si un paso falla:
+
+```
+⚠️ El paso [nombre] encontró un problema:
+  [descripción del error]
+
+Opciones:
+  r → reintentar el paso
+  s → saltar y continuar
+  i → inspeccionar manualmente
+  q → salir (el progreso está guardado)
+```
+
+El estado guardado en `estado.json` permite retomar donde se quedó.

package/commands/sdd.crear-mcp.md

@@ -12,6 +12,8 @@ handoffs:
 
 Eres el **Generador de MCP**. Tomas una descripción en lenguaje natural y produces un servidor MCP completo: tools definidas, empaquetado, instrucciones de instalación de una línea. El resultado lo puede instalar alguien que no sabe programar.
 
+> **MCP integrado en v2.6.0:** Playwright (navegación y QA automatizado).
+
 ## PASO 1 — Entender qué capacidades se quieren publicar
 
 Lee el argumento del comando. Si el usuario escribió algo como:

package/commands/sdd.defect-report.md

@@ -0,0 +1,134 @@
+---
+description: Generar reporte de calidad con escape rate y mutaciones
+allowed-tools: Read, Bash
+---
+
+# /sdd.defect-report
+
+Genera un reporte de calidad basado en mutaciones (cambios) de archivos encontrados por QA.
+
+## Uso
+
+```
+/sdd.defect-report
+```
+
+## Qué Muestra
+
+### Resumen Ejecutivo
+
+```
+╔═══════════════════════════════════════════════════════════╗
+║         DEFECT ESCAPE RATE REPORT — 2026-06-14           ║
+╠═══════════════════════════════════════════════════════════╣
+║                                                           ║
+║  Archivos modificados:  12                                ║
+║  Bugs encontrados (QA): 4                                 ║
+║  Bugs en producción:    1                                 ║
+║  ─────────────────────────────────────                    ║
+║  Global Escape Rate:    20% (1 de 5)                      ║
+║                                                           ║
+║  Interpretación:                                          ║
+║    ✅ Muy bien  (1-10%): Calidad excelente               ║
+║    ⚠️  OK       (11-30%): Calidad buena                  ║
+║    🔴 Malo     (31%+):   Calidad baja                    ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+```
+
+### Por Agente
+
+```
+AGENTE         | ARCHIVOS | MUTACIONES | BUGS ENCONTRADOS | QUALITY
+───────────────┼──────────┼────────────┼──────────────────┼─────────
+backend-dev    | 12       | 15         | 3                | 75%
+frontend-dev   | 8        | 12         | 1                | 88%
+tester-qa      | 5        | 8          | 4 (encontrados)  | QA
+revisor        | 3        | 4          | 2                | 67%
+```
+
+### Archivos Inestables
+
+```
+🚨 CRÍTICOS (>5 mutaciones):
+  - src/auth.ts         (7 mutaciones en 2 días)
+  - src/database.ts     (6 mutaciones en 3 días)
+
+⚠️  INESTABLES (2-5 mutaciones):
+  - src/validators.ts   (3 mutaciones)
+  - src/payments.ts     (4 mutaciones)
+```
+
+### Agentes con Mejora Necesaria
+
+```
+📊 ESCALA DE CALIDAD:
+  backend-dev:    ████████░ 75% — Aumentar coverage de tests
+  frontend-dev:   █████████ 88% — Excelente
+  revisor:        ██████░░░ 67% — Revisar proceso de verificación
+```
+
+---
+
+## Interpretación de Resultados
+
+### Escape Rate Bajo (1-10%)
+```
+✅ QA es efectivo, código es estable
+  → Confiable para producción
+  → Clientes confían en calidad
+```
+
+### Escape Rate Medio (11-30%)
+```
+⚠️  QA encuentra mayoría de bugs, pero algunos escapan
+  → Aumentar cobertura de tests
+  → Mejorar criterios de aceptación
+```
+
+### Escape Rate Alto (31%+)
+```
+🔴 Problemas serios de calidad
+  → Tests insuficientes
+  → Falta validación
+  → Riesgo de producción
+```
+
+---
+
+## Ejemplo Real
+
+**Sesión 1 (2026-06-10):**
+- Backend Dev escribe src/auth.ts (Write)
+- Frontend Dev modifica src/ui.tsx (Edit)
+- Tester QA ejecuta tests, encuentra 2 bugs en auth.ts
+
+**Sesión 2 (2026-06-11):**
+- Backend Dev reescribe src/auth.ts (Write) — 2 bugs solucionados + 1 nuevo
+- Tester QA ejecuta tests, encuentra 2 bugs (1 viejo, 1 nuevo)
+- 1 bug anterior escapó a producción
+
+**Reporte Final:**
+```
+Archivos: 2
+Bugs encontrados: 4
+Bugs en prod: 1
+─────────────────
+Escape Rate: 25%
+
+Por agente:
+  backend-dev: 6 mutaciones, 3 bugs encontrados → 50% quality
+  frontend-dev: 1 mutación, 0 bugs → 100% quality
+  tester-qa: 100% accuracy (encontró todos excepto 1 que escapó)
+```
+
+---
+
+## Datos Fuente
+
+Utiliza:
+- `.sdd/observabilidad/mutaciones.jsonl` — cambios a archivos
+- `.sdd/observabilidad/consumo.jsonl` — timestamps de eventos
+
+**Nota:** En v2.6.1 se agregará integración con resultados reales de QA (Playwright).
+

package/commands/sdd.descubrir.md

@@ -32,8 +32,27 @@ cat .sdd/memoria/constitucion.md 2>/dev/null | head -10 && echo "EXISTE_CONSTITU
 # ¿Es un proyecto existente? Si hay código, invocar al investigador antes de preguntar
 ls package.json pyproject.toml Cargo.toml go.mod 2>/dev/null | head -5
 ls src/ app/ lib/ 2>/dev/null | head -3
+
+# ¿Hay perfil configurado?
+PERFIL=$(grep -o '"perfil": *"[^"]*"' .sdd/estado.json 2>/dev/null | cut -d'"' -f4)
+[ -z "$PERFIL" ] && PERFIL=$(grep '^perfil:' .sdd/sdd.config.yaml 2>/dev/null | cut -d':' -f2 | tr -d ' ')
+echo "PERFIL=${PERFIL:-guiado}"
 ```
 
+### Detección de usuario nuevo
+
+Si NO existe `.sdd/estado.json` ni `.sdd/sdd.config.yaml` y no hay código previo en el proyecto:
+
+**→ Usuario nuevo detectado. Usa modo guiado.**
+
+No pidas que editen archivos ni que ejecuten comandos. Saluda en lenguaje natural:
+
+> ¡Hola! Cuéntame qué quieres construir — una frase es suficiente. No necesitas saber nada técnico para empezar.
+
+Si existe `.sdd/sdd.config.yaml` con `perfil: experto` explícito:
+
+**→ Usuario avanzado. Usa modo experto** (muestra comandos, rutas, estado técnico).
+
 Si el proyecto ya tiene código (existe `src/`, `app/`, o un archivo de manifiesto), invoca al agente **investigador** antes del PASO 1:
 
 > `@investigador` Analiza el proyecto existente y genera el informe de contexto técnico. Quiero usarlo como base antes de especificar algo nuevo.