sdd-es 2.0.0 → 2.5.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.dise/303/261ar.md

@@ -0,0 +1,188 @@
+---
+description: Fase de diseño de FORGE. Orquesta direction picker → product-designer → architecture-designer → wireframe-mvp → critica-diseno. Requiere IR previo en .sdd/ir.json.
+allowed-tools: Read, Write, Bash, Agent
+---
+
+# /sdd.diseñar — Diseño de Producto
+
+**Uso:**
+```
+/sdd.diseñar
+/sdd.diseñar confirmar
+/sdd.diseñar cambiar-direccion
+/sdd.diseñar --sin-critica
+```
+
+---
+
+## PASO 1 — Verificar IR
+
+```bash
+if [ ! -f ".sdd/ir.json" ]; then
+  echo "No hay IR todavía. Primero interpreta tu idea:"
+  echo "  /sdd.interpretar [tu idea]"
+  exit 0
+fi
+
+cat .sdd/ir.json | node -e "
+  const ir = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8'));
+  console.log('Producto:', ir.product.name);
+  console.log('Tipo:', ir.product.type);
+"
+```
+
+Si ya hay un `product-design.json`, pregunta:
+
+```
+Ya tienes un diseño para [product.name].
+¿Qué quieres hacer?
+  1) Ver el diseño actual → /sdd.diseñar ver
+  2) Rediseñar (conservar el IR) → /sdd.diseñar rediseñar
+  3) Continuar al código → /sdd.construir
+```
+
+---
+
+## PASO 2 — Direction Picker
+
+Si no hay `design_direction` en `.sdd/estado.json`, invocar la skill `elegir-direccion`:
+
+La skill muestra 3 opciones visuales y espera la elección del usuario.
+
+Después de elegida, guarda en `.sdd/estado.json`:
+```json
+{ "design_direction": "[direction]", "design_system_path": "{PLUGIN_DIR}/design-systems/[direction]/DESIGN.md" }
+```
+
+Si ya hay dirección elegida, saltarla (a menos que sea `cambiar-direccion`).
+
+---
+
+## PASO 3 — Invocar Product Designer
+
+Activa el agente `product-designer`.
+
+El agente:
+1. Lee `.sdd/ir.json`
+2. Lee `.sdd/estado.json` (dirección y DESIGN.md)
+3. Lee `{PLUGIN_DIR}/craft/anti-ai-slop.md`
+4. Genera el `ProductDesign` JSON
+5. Muestra resumen al usuario
+6. Guarda en `.sdd/product-design.json`
+
+---
+
+## PASO 4 — Invocar Architecture Designer
+
+Activa el agente `architecture-designer`.
+
+El agente:
+1. Lee `.sdd/ir.json` + `.sdd/product-design.json`
+2. Propone el stack más simple viable
+3. Muestra resumen en lenguaje natural
+4. Agrega el campo `architecture` a `.sdd/product-design.json`
+
+---
+
+## PASO 5 — Generar Wireframe (pantalla P0)
+
+Invocar la skill `wireframe-mvp`.
+
+La skill:
+1. Lee `.sdd/product-design.json` (pantalla P0)
+2. Lee el DESIGN.md activo
+3. Lee `{PLUGIN_DIR}/craft/anti-ai-slop.md`
+4. Genera el HTML de la pantalla P0
+5. Guarda en `.sdd/diseño/wireframe-pantalla-principal.html` con la tool `Write`
+6. Abre el archivo en el navegador del sistema (`start`/`open`/`xdg-open`)
+
+Si se pasa `--sin-critica`, saltar el PASO 6.
+
+---
+
+## PASO 6 — Crítica y Refinamiento
+
+Invocar la skill `critica-diseno`.
+
+La skill:
+1. Lee el wireframe generado
+2. Evalúa en 5 dimensiones (score 1–5 cada una)
+3. Si score < 4 y iteraciones < 3: refina el wireframe y re-evalúa
+4. Si score ≥ 4: aprueba y termina
+5. Muestra el resultado de la crítica al usuario
+
+---
+
+## PASO 7 — Confirmar y guardar
+
+Muestra resumen final del diseño:
+
+```
+═══════════════════════════════════════════
+✅ DISEÑO COMPLETADO
+═══════════════════════════════════════════
+
+Producto: [product.name]
+Dirección visual: [design_direction]
+Pantallas: [N] pantallas ([nombres P0, P1, P2])
+Stack: [frontend] + [backend] + [database]
+Wireframe: .sdd/diseño/wireframe-pantalla-principal.html
+Score del diseño: [X]/5
+
+¿Listo para generar el código?
+  /sdd.construir     → Pipeline completo automático
+  /sdd.diseñar ver   → Ver el diseño en detalle
+```
+
+Actualizar `.sdd/estado.json`:
+
+```bash
+node -e "
+  const fs = require('fs');
+  const estado = JSON.parse(fs.readFileSync('.sdd/estado.json', 'utf8') || '{}');
+  estado.product_design_aprobado = true;
+  estado.ultima_actualizacion = new Date().toISOString();
+  fs.writeFileSync('.sdd/estado.json', JSON.stringify(estado, null, 2));
+"
+```
+
+---
+
+## Sub-comandos
+
+### `/sdd.diseñar ver`
+Muestra el ProductDesign actual en formato legible (pantallas, stack, wireframe path).
+
+### `/sdd.diseñar confirmar`
+Si el diseño ya fue generado pero esperaba confirmación explícita, lo confirma y continúa.
+
+### `/sdd.diseñar cambiar-direccion`
+Vuelve al PASO 2 (direction picker) sin borrar el IR. Regenera todo lo demás.
+
+### `/sdd.diseñar rediseñar`
+Borra el ProductDesign actual y vuelve a empezar desde el PASO 2, conservando el IR.
+
+---
+
+## Archivos generados
+
+```
+.sdd/
+  product-design.json              ← ProductDesign + ArchitectureDesign
+  estado.json                      ← product_design_aprobado: true
+  diseño/
+    wireframe-pantalla-principal.html  ← Wireframe de P0
+    critica-wireframe.md               ← Resultado de la crítica
+```
+
+---
+
+## Integración con el pipeline
+
+Después de `/sdd.diseñar`:
+
+```
+/sdd.construir   → Pipeline completo: spec + plan + tareas + código
+/sdd.exportar    → Exportar bundle del proyecto
+/sdd.estado      → Ver estado del proyecto
+```