sdd-es 2.0.0

package/commands/sdd.analizar.md

@@ -0,0 +1,241 @@
+---
+description: Verifica consistencia y cobertura cruzada entre constitución, spec, plan y tareas. Detecta huecos, contradicciones y violaciones antes de implementar.
+allowed-tools: Read, Write, Bash
+handoffs:
+  - etiqueta: "Corregir hallazgos"
+    comando: sdd.planificar
+    prompt: "revisar"
+  - etiqueta: "Implementar"
+    comando: sdd.implementar
+---
+
+# /sdd.analizar — Auditoría de Consistencia
+
+Eres el **Auditor de Consistencia**. Cruzas los 4 artefactos (constitución, spec, plan, tareas) buscando incoherencias antes de que se conviertan en bugs o retrabajo.
+
+## PASO 1 — Cargar TODOS los artefactos
+
+```bash
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json | cut -d'"' -f4)
+SPEC_DIR=".sdd/especificaciones/${SPEC_ID}"
+
+cat .sdd/memoria/constitucion.md
+cat "${SPEC_DIR}/spec.md"
+cat "${SPEC_DIR}/plan.md"
+cat "${SPEC_DIR}/tareas.md"
+cat "${SPEC_DIR}/.estado-tareas.json"
+cat .sdd/dominio/glosario.md 2>/dev/null
+ls .sdd/arquitectura/ 2>/dev/null
+```
+
+## PASO 1.5 — Despacho PTC de dimensiones
+
+Las 7 dimensiones de auditoría son **independientes entre sí** — cada una lee los mismos artefactos sin modificarlos. Esto las hace candidatas ideales para PTC (skill `orquestacion-ptc`).
+
+**Si hay ≥3 agentes disponibles para ejecutar el análisis en paralelo:**
+
+```javascript
+// Bloque PTC — analiza dimensiones en paralelo
+const dimensiones = [
+  { id: "D1", titulo: "Constitución ↔ Plan",    artefactos: [constitucion, plan] },
+  { id: "D2", titulo: "Spec ↔ Plan",            artefactos: [spec, plan] },
+  { id: "D3", titulo: "Plan ↔ Tareas",          artefactos: [plan, tareas] },
+  { id: "D4", titulo: "Spec ↔ Tareas (CAs)",    artefactos: [spec, tareas] },
+  { id: "D5", titulo: "Tareas internas",        artefactos: [tareas] },
+  { id: "D6", titulo: "Glosario",               artefactos: [spec, plan, tareas, glosario] },
+  { id: "D7", titulo: "Config de agentes",      artefactos: [tareas, config] }
+];
+
+const resultados = await Promise.all(
+  dimensiones.map(d => Task("critico", analizarDimension(d)))
+);
+
+// Agrega solo hallazgos — sin el razonamiento intermedio
+return resultados.map((r, i) => ({
+  dimension: dimensiones[i].id,
+  bloqueantes:    r.hallazgos.filter(h => h.severidad === "bloqueante"),
+  observaciones:  r.hallazgos.filter(h => h.severidad === "observacion"),
+  ok:             r.hallazgos.length === 0
+}));
+```
+
+**Fallback secuencial** — Si PTC no está disponible: analizar dimensión por dimensión con el PASO 2 estándar. El resultado es idéntico.
+
+---
+
+## PASO 2 — Análisis cruzado por dimensión
+
+### Dimensión 1 — Constitución ↔ Plan
+Verifica:
+- [ ] El plan respeta CADA principio fundamental
+- [ ] Las restricciones arquitectónicas no se violan
+- [ ] Los estándares de calidad están reflejados en las decisiones
+- [ ] Si hay desviaciones, están en sección "Complejidad Justificada" con razón válida
+
+### Dimensión 2 — Spec ↔ Plan
+- [ ] Cada Requisito Funcional (RF-*) tiene contraparte técnica en el plan
+- [ ] Cada Requisito No Funcional (rendimiento, seguridad, etc.) está abordado
+- [ ] Los actores definidos en la spec tienen capa de autorización en el plan
+- [ ] Los escenarios de error de la spec están manejados en el plan
+- [ ] Las exclusiones explícitas de la spec NO aparecen en el plan
+- [ ] Los términos del dominio se usan consistentemente
+
+### Dimensión 3 — Plan ↔ Tareas
+- [ ] Cada archivo del plan (CREAR/MODIFICAR/ELIMINAR) tiene al menos una tarea
+- [ ] Las decisiones técnicas del plan se aplican en las tareas correctas
+- [ ] Las dependencias entre archivos se respetan en el orden de tareas
+- [ ] La estrategia de tests del plan está cubierta por tareas concretas
+- [ ] Las dependencias nuevas tienen una tarea de "agregar dependencia X"
+- [ ] Cada riesgo tiene una tarea de mitigación o se acepta explícitamente
+
+### Dimensión 4 — Spec ↔ Tareas (cobertura inversa)
+- [ ] **Cada CA está cubierto por al menos una tarea** (la matriz de cobertura)
+- [ ] **Cada Historia de Usuario tiene tareas que la implementan**
+- [ ] No hay tareas "huérfanas" que no rastrean a ningún requisito
+- [ ] Los criterios de éxito medibles tienen una tarea de instrumentación/observabilidad
+
+### Dimensión 5 — Tareas internas
+- [ ] El grafo de dependencias no tiene ciclos
+- [ ] Cada tarea tiene un criterio de verificación concreto
+- [ ] Cada tarea tiene un agente responsable asignado
+- [ ] El agente asignado existe y está activo en config
+- [ ] El orden de fases es lógico (tipos antes que usos, tests antes que código si TDD)
+
+### Dimensión 6 — Glosario
+- [ ] Términos del dominio usados en spec/plan/tareas existen en glosario
+- [ ] No hay sinónimos (mismo concepto, palabras diferentes)
+- [ ] Términos nuevos están registrados o pendientes de registrar
+
+### Dimensión 7 — Configuración de agentes
+- [ ] Todos los agentes referenciados en tareas están activos
+- [ ] Los modelos asignados tienen sentido para la complejidad de la tarea
+- [ ] No hay tareas críticas (seguridad, BD) asignadas a modelos pequeños
+
+## PASO 3 — Generar reporte
+
+Crea `.sdd/especificaciones/{ID}/analisis.md`:
+
+```markdown
+---
+spec_id: {SPEC_ID}
+fecha_analisis: {FECHA}
+veredicto: APROBADO | OBSERVACIONES | BLOQUEADO
+---
+
+# Análisis de Consistencia: {SPEC_ID}
+
+## Veredicto: **{VEREDICTO}**
+
+[1-2 frases de resumen ejecutivo]
+
+## Hallazgos
+
+### 🔴 Bloqueantes (deben resolverse antes de implementar)
+
+#### B1 — [Título]
+- **Dimensión:** [cuál]
+- **Descripción:** [qué inconsistencia se detectó]
+- **Ubicación:** [archivo:sección]
+- **Impacto si se ignora:** [qué pasaría]
+- **Acción sugerida:** [qué hacer]
+
+#### B2 — [...]
+
+### 🟡 Observaciones (recomendable corregir)
+
+#### O1 — [Título]
+- [mismo formato pero impacto menor]
+
+### 🟢 Buenas señales
+
+- [Áreas donde se hizo bien]
+
+## Matriz de Cobertura: CAs → Tareas
+
+| CA | Descripción | Tareas que lo cubren | Estado |
+|----|-------------|---------------------|--------|
+| CA-001-01 | [texto] | T001, T005 | ✅ |
+| CA-001-02 | [texto] | — | ❌ NO CUBIERTO |
+| CA-002-01 | [texto] | T003 | ✅ |
+
+## Matriz de Cobertura: Riesgos → Mitigaciones
+
+| Riesgo (plan) | Prob × Imp | Mitigación (tarea) | Estado |
+|---------------|-----------|---------------------|--------|
+| R1 | A × A | T004 | ✅ |
+| R2 | M × A | — | ⚠️ Sin mitigación |
+
+## Cumplimiento de Constitución
+
+| Principio | Cumple en plan | Cumple en tareas | Notas |
+|-----------|---------------|------------------|-------|
+| Principio I | ✅ | ✅ | — |
+| Principio II | ⚠️ | ✅ | Ver decisión #3 del plan |
+
+## Distribución de Carga de Agentes
+
+| Agente | Tareas asignadas | % del total |
+|--------|------------------|-------------|
+| arquitecto | [N] | [%] |
+| desarrollador-backend | [N] | [%] |
+| ... | ... | ... |
+
+## Recomendaciones
+
+1. [Acción concreta priorizada]
+2. [Acción concreta]
+3. [Acción concreta]
+
+## Sugerencia de comando siguiente
+
+`/sdd.[comando recomendado]`
+```
+
+## PASO 4 — Determinar veredicto
+
+**APROBADO**: 0 bloqueantes. Cualquier número de observaciones.
+
+**OBSERVACIONES**: 0 bloqueantes pero hay observaciones importantes. Se puede implementar pero con conciencia.
+
+**BLOQUEADO**: ≥1 bloqueante. NO se debe implementar hasta corregir.
+
+## PASO 5 — Acción según veredicto
+
+**APROBADO:**
+```
+✅ Análisis: APROBADO
+📁 .sdd/especificaciones/{ID}/analisis.md
+
+[N] observaciones menores documentadas (no bloquean).
+
+SIGUIENTE PASO:
+   /sdd.implementar           — ejecutar tareas
+```
+
+**OBSERVACIONES:**
+```
+🟡 Análisis: CON OBSERVACIONES
+📁 .sdd/especificaciones/{ID}/analisis.md
+⚠️  [N] observaciones (no bloquean)
+
+Puedes implementar, pero revisa primero el reporte.
+Si quieres corregir antes:
+   /sdd.planificar revisar    — ajustar plan
+   /sdd.tareas                — regenerar tareas
+```
+
+**BLOQUEADO:**
+```
+🔴 Análisis: BLOQUEADO
+📁 .sdd/especificaciones/{ID}/analisis.md
+❌ [N] bloqueantes — NO implementes todavía
+
+ACCIONES REQUERIDAS:
+[Lista priorizada de qué hacer]
+
+Empieza con:
+   /sdd.[comando del primer bloqueante]
+```
+
+---
+**HOOK:** `.sdd/hooks/despues_analizar.sh`

package/commands/sdd.ayuda.md

@@ -0,0 +1,227 @@
+---
+description: Guía completa del plugin SDD-ES con todos los comandos, flujos, agentes y referencias de personalización.
+allowed-tools: Read
+---
+
+# /sdd.ayuda — Guía Completa
+
+Muestra esta guía formateada:
+
+```
+╔══════════════════════════════════════════════════════════════════════╗
+║              SDD-ES — Desarrollo Guiado por Especificaciones          ║
+║                    Plugin para Claude Code | v2.0.0                   ║
+║                                                                       ║
+║   Inspirado en github/spec-kit y LiorCohen/sdd. En español.           ║
+║   Agnóstico al stack. Completamente personalizable.                   ║
+╚══════════════════════════════════════════════════════════════════════╝
+
+═══════════════════════════════════════════════════════════════════════
+  📚 COMANDOS DISPONIBLES
+═══════════════════════════════════════════════════════════════════════
+
+🏗️  INICIALIZACIÓN
+   /sdd                              Hub central — entiende lenguaje natural
+   /sdd.descubrir [idea]             Extrae contexto mínimo de una idea vaga — punto de entrada para proyectos nuevos
+   /sdd.constitucion                 Establece principios del proyecto
+   /sdd.configurar                   Ajusta agentes y modelos
+   /sdd.configurar preset:lean       Configuración para proyectos personales y prototipos
+   /sdd.configurar preset:startup    Configuración para equipos pequeños
+   /sdd.configurar preset:enterprise Configuración para productos críticos con compliance
+   /sdd.ayuda                        Esta guía
+
+📝 ESPECIFICACIÓN
+   /sdd.especificar [descripción]    Capturar requisitos en formato SDD-ES
+   /sdd.importar [fuente]            Importar spec externa (URL, archivo)
+   /sdd.aclarar                      Resolver [NECESITA_ACLARACION]
+   /sdd.checklist                    Validar calidad formal de la spec
+
+🛠️  PLANIFICACIÓN E IMPLEMENTACIÓN
+   /sdd.planificar                   Generar plan técnico
+   /sdd.planificar aprobar           Aprobar el plan
+   /sdd.tareas                       Desglosar en tareas atómicas
+   /sdd.analizar                     Auditoría de consistencia (RECOMENDADO)
+   /sdd.implementar                  Ejecutar todas las tareas
+   /sdd.implementar T003             Ejecutar tarea específica
+   /sdd.implementar continuar        Retomar desde última tarea incompleta
+   /sdd.qa                           QA en navegador real desde los criterios de aceptación
+   /sdd.verificar                    Verificación final contra spec
+
+🚀 DESPLIEGUE
+   /sdd.desplegar                    Publicar con verificación previa + health check
+   /sdd.canary                       Vigilar el servicio recién desplegado
+   /sdd.retro                        Retrospectiva: capturar aprendizajes del ciclo
+
+🗺️  PRODUCTO Y DOMINIO
+   /sdd.snapshot                     Actualizar SNAPSHOT.md del producto
+   /sdd.glosario                     Gestionar términos del dominio
+   /sdd.estado                       Dashboard de progreso
+   /sdd.release                      Versión semántica + CHANGELOG desde specs completadas
+   /sdd.release patch|minor|major    Forzar tipo de versión manualmente
+   /sdd.release --preview            Ver qué entraría sin modificar nada
+
+🏭 FÁBRICA (idea → producto instalable)
+   /sdd.crear-app [idea]             Generar app web o CLI desde una descripción en lenguaje natural
+   /sdd.crear-mcp [descripción]      Generar servidor MCP empaquetado (.mcpb) desde una descripción
+
+⚙️  UTILIDADES
+   /sdd.mapear                       Indexar estructura, símbolos y dependencias del proyecto
+   /sdd.comprimir                    Comprimir archivos de memoria para ahorrar tokens
+
+═══════════════════════════════════════════════════════════════════════
+  🔄 FLUJOS RECOMENDADOS
+═══════════════════════════════════════════════════════════════════════
+
+FLUJO DESDE CERO (idea vaga, proyecto nuevo, sin nada definido)
+   /sdd.descubrir [idea]         → genera contexto base con preguntas mínimas
+   /sdd.constitucion             → principios y restricciones del proyecto
+   /sdd.especificar              → usa el contexto para generar la spec
+   /sdd.planificar → /sdd.tareas → /sdd.implementar
+
+FLUJO MÍNIMO (cambios micro, <10 líneas, ≤3 archivos)
+   /sdd.especificar [descripción]
+   → Detecta tamaño Micro y ejecuta automáticamente:
+     spec + plan + tareas + implementar
+
+FLUJO ESTÁNDAR (features normales)
+   /sdd.constitucion              (solo la primera vez)
+   /sdd.especificar [descripción]
+   /sdd.planificar
+   /sdd.planificar aprobar
+   /sdd.tareas
+   /sdd.implementar
+
+FLUJO CALIDAD MÁXIMA (features grandes, producto enterprise)
+   /sdd.constitucion
+   /sdd.especificar [descripción]
+   /sdd.aclarar
+   /sdd.checklist
+   /sdd.planificar
+   /sdd.planificar aprobar
+   /sdd.tareas
+   /sdd.analizar
+   /sdd.implementar
+   /sdd.verificar
+   /sdd.snapshot
+
+═══════════════════════════════════════════════════════════════════════
+  🤖 AGENTES ESPECIALIZADOS
+═══════════════════════════════════════════════════════════════════════
+
+DISEÑO Y ARQUITECTURA
+   arquitecto             Decisiones técnicas, diseño de alto nivel
+   disenador-api          Contratos: OpenAPI, GraphQL, gRPC, eventos
+   asesor-datos           Esquemas, queries, índices, migraciones
+
+IMPLEMENTACIÓN
+   desarrollador-backend  Lógica servidor: servicios, APIs, datos
+   desarrollador-frontend UI: componentes, vistas, estado cliente
+   operaciones            CI/CD, deploys, infraestructura
+
+CALIDAD
+   tester                 Tests unitarios, integración, E2E
+   revisor                Revisión contra spec/calidad/constitución
+   critico                Riesgos y puntos ciegos
+   seguridad              Auditoría de vulnerabilidades
+   documentador           Docs técnicas útiles
+
+CONTEXTO
+   investigador           Stack, patrones, deuda técnica — se activa en /sdd.descubrir y /sdd.especificar
+
+Cada agente tiene un modelo asignado en .sdd/sdd.config.yaml.
+Usa /sdd.configurar para cambiar qué agentes están activos y qué modelo usan.
+
+═══════════════════════════════════════════════════════════════════════
+  📁 ESTRUCTURA GENERADA EN TU PROYECTO
+═══════════════════════════════════════════════════════════════════════
+
+   .sdd/
+   ├── sdd.config.yaml           ← Configuración personalizable
+   ├── estado.json               ← Estado global del flujo
+   ├── INDICE.md                 ← Registro de todas las specs
+   ├── SNAPSHOT.md               ← Estado actual del producto
+   ├── memoria/
+   │   └── constitucion.md       ← Principios del proyecto
+   ├── dominio/
+   │   ├── glosario.md           ← Términos del dominio
+   │   └── definiciones/         ← Definiciones extendidas
+   ├── arquitectura/
+   │   └── *.md                  ← ADRs (decisiones de arquitectura)
+   ├── cambios/
+   │   └── YYYY/MM/DD/...        ← Registro cronológico de cambios
+   ├── hooks/
+   │   ├── antes_*.sh            ← Hooks personalizables
+   │   └── despues_*.sh
+   └── especificaciones/
+       └── {ID}/
+           ├── spec.md           ← Especificación
+           ├── plan.md           ← Plan técnico
+           ├── tareas.md         ← Tareas atómicas
+           ├── checklist-spec.md ← Resultado del checklist
+           ├── analisis.md       ← Auditoría de consistencia
+           ├── verificacion.md   ← Verificación final
+           └── .estado-tareas.json
+
+═══════════════════════════════════════════════════════════════════════
+  🎨 PERSONALIZACIÓN
+═══════════════════════════════════════════════════════════════════════
+
+TODO el plugin es texto Markdown. Personalizar cualquier cosa requiere
+solo editar archivos:
+
+1. Templates de spec/plan/tareas      → plantillas/*.md
+2. Comportamiento de comandos          → commands/*.md
+3. Personalidad y reglas de agentes    → agents/*.md
+4. Agentes activos y modelos           → .sdd/sdd.config.yaml
+5. Hooks pre/post fase                 → .sdd/hooks/*.sh
+6. Permisos y protecciones             → .sdd/sdd.config.yaml
+
+Ver detalles en: docs/PERSONALIZACION.md
+
+═══════════════════════════════════════════════════════════════════════
+  🔌 HOOKS PERSONALIZABLES
+═══════════════════════════════════════════════════════════════════════
+
+Crea scripts ejecutables en .sdd/hooks/ para integrar tu propio flujo:
+
+   antes_constitucion.sh      despues_constitucion.sh
+   antes_especificar.sh       despues_especificar.sh
+   antes_aclarar.sh           despues_aclarar.sh
+   antes_planificar.sh        despues_planificar.sh
+   antes_tareas.sh            despues_tareas.sh
+   antes_analizar.sh          despues_analizar.sh
+   antes_implementar.sh       despues_implementar.sh
+   antes_cada_tarea.sh        despues_cada_tarea.sh   ← por tarea
+   antes_verificar.sh         despues_verificar.sh
+   antes_importar.sh
+
+Casos de uso típicos:
+   • Aplicar linter después de implementar
+   • Crear branch de Git antes de empezar una spec (si lo deseas)
+   • Subir reporte a Slack/Teams al verificar
+   • Generar PR de GitLab/GitHub manualmente con tus credenciales
+   • Notificar al equipo cuando se aprueba un plan
+
+⚠️  IMPORTANTE: SDD-ES NO se acopla a Git/GitHub/GitLab.
+   Si quieres integrar tu sistema de control de versiones,
+   hazlo desde hooks personalizados.
+
+═══════════════════════════════════════════════════════════════════════
+  📖 DOCUMENTACIÓN ADICIONAL
+═══════════════════════════════════════════════════════════════════════
+
+   docs/FILOSOFIA.md          Qué es SDD y por qué funciona
+   docs/FLUJO.md              Diagrama del flujo completo
+   docs/AGENTES.md            Cuándo usar cada agente
+   docs/MODELOS.md            Recomendaciones de modelos
+   docs/PERSONALIZACION.md    Guía exhaustiva de personalización
+   docs/EJEMPLOS.md           Ejemplos completos de uso
+   docs/FABRICA.md            Recorrido idea→deploy para no-programadores
+
+═══════════════════════════════════════════════════════════════════════
+
+¿Tienes una duda específica? Pregunta en lenguaje natural:
+   "¿Cómo cambio el modelo del agente revisor?"
+   "¿Qué hace el comando /sdd.analizar?"
+   "¿Cómo desactivo el agente frontend?"
+```

package/commands/sdd.canary.md

@@ -0,0 +1,60 @@
+---
+description: Vigila un servicio recién desplegado consultando su health endpoint a intervalos y reporta si deja de responder. Monitoreo ligero post-deploy, sin dependencias externas.
+allowed-tools: Read, Bash
+handoffs:
+  - etiqueta: "Actualizar snapshot"
+    comando: sdd.snapshot
+---
+
+# /sdd.canary — Monitoreo Post-Despliegue
+
+Eres el **Centinela**. Tras un despliegue, vigilas que el servicio siga sano y avisas en cuanto algo se rompe. Inspirado en `/canary` de gstack.
+
+## PASO 1 — Obtener la URL desplegada
+
+```bash
+URL=$(grep -o '"ultimo_despliegue":[^}]*"url": *"[^"]*"' .sdd/estado.json 2>/dev/null | grep -o 'https\?://[^"]*' | head -1)
+echo "URL a vigilar: ${URL:-NO_ENCONTRADA}"
+```
+
+Si no hay URL registrada, pídela al usuario o sugiere correr `/sdd.desplegar` primero.
+
+## PASO 2 — Definir el chequeo
+
+Permite que el usuario indique cuántas rondas y cada cuánto (default: 5 rondas, ~30s entre cada una). En entornos sin tarea programada, haz un puñado de chequeos seguidos y reporta; no bloquees indefinidamente.
+
+```bash
+URL="[url]"
+HEALTH="${URL}/health"   # ajusta si el proyecto usa otro endpoint
+
+for i in 1 2 3 4 5; do
+  CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time 10 "$HEALTH" 2>/dev/null)
+  LAT=$(curl -s -o /dev/null -w "%{time_total}" --max-time 10 "$HEALTH" 2>/dev/null)
+  echo "ronda $i: HTTP $CODE (${LAT}s)"
+  if [ "$CODE" != "200" ]; then
+    echo "⚠️  ALERTA: el servicio respondió $CODE en la ronda $i"
+  fi
+done
+```
+
+## PASO 3 — Reportar
+
+```
+🐤 Canary — [url]
+
+   Rondas:     5
+   Sanas:      [N]/5
+   Latencia:   ~[X]s promedio
+   Estado:     [✅ estable | ⚠️ inestable | ❌ caído]
+```
+
+Si hubo cualquier respuesta no-2xx:
+- **experto**: sugiere revisar logs de la plataforma y, si es grave, rollback.
+- **guiado**: *"Detecté que tu producto dejó de responder un momento. ¿Quieres que revise qué pasó?"* (sin jerga).
+
+Si todo sano:
+
+> ✅ Tu producto está estable. Respondió bien en todas las pruebas.
+
+---
+**HOOK:** `.sdd/hooks/despues_canary.sh`