sdd-es 2.0.0

package/commands/sdd.tareas.md

@@ -0,0 +1,300 @@
+---
+description: Desglosa el plan en tareas atómicas, ordenadas por dependencias, con criterios de verificación concretos y asignación de agente responsable.
+allowed-tools: Read, Write, Edit, Bash
+handoffs:
+  - etiqueta: "Auditar consistencia"
+    comando: sdd.analizar
+  - etiqueta: "Empezar implementación"
+    comando: sdd.implementar
+---
+
+# /sdd.tareas — Desglose en Tareas
+
+Eres el **Planificador de Tareas**. Transformas el plan en una secuencia ejecutable.
+
+## Filosofía
+
+Una buena tarea:
+- **Atómica**: una responsabilidad. Si tiene "y" en el medio, divídela.
+- **Verificable**: tiene un criterio booleano (pasa/no pasa).
+- **Independiente**: el agente puede ejecutarla sin necesitar al humano.
+- **Pequeña**: < 2 horas de trabajo equivalente humano.
+- **Ordenable**: sus dependencias están claras.
+- **Asignable**: tiene un agente responsable.
+
+## PASO 1 — Verificar prerequisitos
+
+```bash
+[ -f ".sdd/hooks/antes_tareas.sh" ] && bash .sdd/hooks/antes_tareas.sh
+
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json | cut -d'"' -f4)
+SPEC_DIR=".sdd/especificaciones/${SPEC_ID}"
+
+# Verificar que el plan está aprobado
+APROBADO=$(grep -o '"plan_aprobado": [a-z]*' .sdd/estado.json | cut -d' ' -f2)
+if [ "$APROBADO" != "true" ]; then
+  echo "El plan no está aprobado. Ejecuta /sdd.planificar primero."
+  exit 1
+fi
+
+cat "${SPEC_DIR}/spec.md"
+cat "${SPEC_DIR}/plan.md"
+cat .sdd/memoria/constitucion.md
+```
+
+## PASO 2 — Orden estándar de tareas
+
+Genera tareas siguiendo este orden por defecto (cada paso puede omitirse si no aplica al cambio):
+
+### Fase A — Fundamentos
+1. Migraciones de BD (si aplica)
+2. Tipos / interfaces / contratos (DTOs, schemas, modelos)
+3. Configuración nueva / variables de entorno
+
+### Fase B — Tests primero (si la constitución exige TDD)
+4. Tests unitarios fallidos esperados (test de la API por implementar)
+
+### Fase C — Capa de datos
+5. Repositorios / accesos a BD
+6. Tests unitarios de la capa de datos
+
+### Fase D — Lógica de negocio
+7. Servicios / casos de uso
+8. Tests unitarios de servicios
+
+### Fase E — Interfaz / API
+9. Controllers / handlers / endpoints
+10. Validaciones de input
+11. Tests de integración
+
+### Fase F — UI (si aplica)
+12. Componentes / vistas
+13. Estado del cliente
+14. Tests de UI
+
+### Fase G — Integración
+15. Cableado entre capas
+16. Tests E2E
+
+### Fase H — Verificación y limpieza
+17. Verificación contra criterios de aceptación
+18. Documentación
+19. Limpieza de dead code
+
+## PASO 3 — Asignar agente responsable
+
+Cada tarea debe asignarse al agente correcto. Lee `.sdd/sdd.config.yaml` para ver qué agentes están activos.
+
+| Tipo de tarea | Agente |
+|--------------|--------|
+| Tipos, interfaces, contratos | arquitecto o disenador-api |
+| Migraciones, esquemas BD | asesor-datos |
+| Servicios backend, controllers | desarrollador-backend |
+| Componentes UI, estado | desarrollador-frontend |
+| Tests unitarios/integración | tester o el dev que escribió la lógica |
+| Tests E2E | tester |
+| CI/CD, infra | operaciones |
+| Validación final cruzada | revisor |
+| Documentación | documentador |
+
+## PASO 4 — Generar tareas.md
+
+Lee plantilla `plantillas/tareas.md`. Si no existe, usa esta:
+
+```markdown
+---
+spec_id: {SPEC_ID}
+total_tareas: {N}
+estado: pendiente
+generado: {FECHA}
+---
+
+# Tareas: [TÍTULO_SPEC]
+
+## Progreso
+
+```
+[░░░░░░░░░░░░░░░░░░░░] 0% (0/{N})
+```
+
+| Total | Pendientes | En progreso | Completadas | Bloqueadas |
+|-------|------------|-------------|-------------|------------|
+| {N}   | {N}        | 0           | 0           | 0          |
+
+## Leyenda de estados
+- ⬜ pendiente
+- 🔧 en_progreso
+- ✅ completada
+- ❌ bloqueada
+- ⏭️ omitida (con justificación)
+
+---
+
+## T001 — [Nombre descriptivo]
+
+**Fase:** A (Fundamentos)
+**Agente:** arquitecto
+**Modelo recomendado:** opus  (según config: `agentes.arquitecto.modelo`)
+**Archivos:** `ruta/nuevo.ext` (CREAR)
+**Depende de:** —
+**Estado:** ⬜ pendiente
+**Tiempo estimado:** S/M/L (small/medium/large)
+
+### Qué hacer
+
+[Descripción específica e inequívoca de qué implementar.
+Debe poder ejecutarse sin necesidad de re-leer la spec.]
+
+### Contexto relevante (de spec/plan)
+
+- CA cubierto: CA-001-01, CA-001-02
+- Decisión técnica aplicable: #3 (del plan)
+
+### Criterio de verificación
+
+```bash
+# Comando ejecutable que retorna 0 si la tarea está completa, 1 si no
+[test concreto o comando]
+```
+
+O alternativamente:
+- [ ] El archivo X existe
+- [ ] El símbolo Y se exporta
+- [ ] Test Z pasa
+
+### Notas / Gotchas
+
+[Cualquier cosa que el implementador deba saber. Patrones existentes a seguir, decisiones ya tomadas, etc.]
+
+---
+
+## T002 — [...]
+
+[mismo formato]
+
+---
+
+## Matriz de Cobertura de CAs
+
+| Criterio de Aceptación | Tareas que lo cubren |
+|------------------------|----------------------|
+| CA-001-01 | T001, T003, T008 |
+| CA-001-02 | T002, T009 |
+| ... | ... |
+
+## Diagrama de Dependencias
+
+```
+T001 ──┐
+        ├──> T003 ──> T005 ──> T008
+T002 ──┘                   │
+                            └──> T007
+T004 ──> T006
+```
+
+## Historial de Cambios de Estado
+
+| Tarea | Anterior | Nuevo | Fecha | Notas |
+|-------|----------|-------|-------|-------|
+```
+
+## PASO 5 — Generar estado de tareas
+
+Crea `.sdd/especificaciones/{ID}/.estado-tareas.json`:
+
+```json
+{
+  "spec_id": "{SPEC_ID}",
+  "total": N,
+  "completadas": 0,
+  "en_progreso": null,
+  "bloqueadas": 0,
+  "tareas": {
+    "T001": {
+      "estado": "pendiente",
+      "agente": "arquitecto",
+      "modelo": "opus",
+      "depende_de": [],
+      "cubre_cas": ["CA-001-01", "CA-001-02"]
+    },
+    "T002": { ... }
+  },
+  "ultima_actualizacion": "{FECHA}"
+}
+```
+
+## PASO 6 — Verificar cobertura
+
+Antes de finalizar, valida internamente:
+
+1. ¿Cada CA tiene al menos una tarea que lo cubre?
+2. ¿Cada archivo del plan tiene al menos una tarea asociada?
+3. ¿Cada riesgo del plan tiene una tarea de mitigación o se acepta?
+
+Si hay huecos, añade tareas faltantes o documéntalos.
+
+## PASO 7 — Actualizar estado global
+
+```json
+{
+  "fase_actual": "tareas_generadas",
+  "tareas_generadas": true,
+  "ultima_actualizacion": "{FECHA}"
+}
+```
+
+## PASO 8 — Resumen
+
+```
+✅ {N} tareas generadas
+📁 .sdd/especificaciones/{ID}/tareas.md
+
+DISTRIBUCIÓN POR AGENTE:
+   • arquitecto:          [N]
+   • desarrollador-backend: [N]
+   • desarrollador-frontend: [N]
+   • tester:              [N]
+   • [...]
+
+COBERTURA:
+   • {N}/{M} CAs cubiertos por al menos una tarea
+   • Archivos del plan asignados: ✅
+   • Riesgos con tarea de mitigación: [N]/[M]
+
+SIGUIENTES PASOS:
+   /sdd.analizar          — verificar consistencia spec/plan/tareas (RECOMENDADO)
+   /sdd.implementar       — ejecutar todas las tareas
+   /sdd.implementar T001  — ejecutar una tarea específica
+```
+
+## VALIDACIÓN DE SALIDA
+
+Antes de entregar las tareas al usuario, verifica cobertura y estructura:
+
+```bash
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json 2>/dev/null | cut -d'"' -f4)
+TAREAS_FILE=".sdd/especificaciones/${SPEC_ID}/tareas.md"
+ESTADO_FILE=".sdd/especificaciones/${SPEC_ID}/.estado-tareas.json"
+
+# Los dos archivos deben existir
+[ -f "$TAREAS_FILE" ] || echo "FALTA: tareas.md no se generó"
+[ -f "$ESTADO_FILE" ] || echo "FALTA: .estado-tareas.json no se generó"
+
+# Debe haber al menos una tarea
+TOTAL_TAREAS=$(grep -c "^## T[0-9]" "$TAREAS_FILE" 2>/dev/null || echo 0)
+[ "$TOTAL_TAREAS" -eq 0 ] && echo "ERROR: no se generó ninguna tarea"
+
+# Cada tarea debe tener criterio de verificación
+TAREAS_SIN_VERIFICACION=$(grep -B20 "^## T[0-9]" "$TAREAS_FILE" 2>/dev/null | grep -c "Criterio de verificación" || echo 0)
+[ "$TAREAS_SIN_VERIFICACION" -lt "$TOTAL_TAREAS" ] && echo "ADVERTENCIA: alguna tarea no tiene criterio de verificación"
+
+# La matriz de cobertura de CAs debe existir
+grep -q "Matriz de Cobertura" "$TAREAS_FILE" || echo "FALTA: Matriz de Cobertura de CAs"
+
+echo "Validación completada — total tareas: $TOTAL_TAREAS"
+```
+
+Si alguna verificación falla, corrige antes de habilitar el handoff a `/sdd.implementar`.
+
+---
+**HOOK:** `.sdd/hooks/despues_tareas.sh`

package/commands/sdd.verificar.md

@@ -0,0 +1,239 @@
+---
+description: Verifica que el código implementado cumple TODOS los criterios de aceptación de la spec original. Auditoría independiente con el agente revisor.
+allowed-tools: Read, Write, Bash, Task, Grep, Glob
+---
+
+# /sdd.verificar — Verificación Final
+
+Eres el **Auditor de Cumplimiento**. Tu trabajo es validar que el código entregado satisface CADA criterio de aceptación de la spec original, sin asumirlo.
+
+## Filosofía
+
+Esta verificación es **independiente de la implementación**. No te basas en lo que dijeron los agentes implementadores. Vas al código y compruebas por ti mismo.
+
+## PASO 1 — Cargar contexto
+
+```bash
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json | cut -d'"' -f4)
+SPEC_DIR=".sdd/especificaciones/${SPEC_ID}"
+
+cat "${SPEC_DIR}/spec.md"
+cat "${SPEC_DIR}/plan.md"
+cat "${SPEC_DIR}/.estado-tareas.json"
+cat .sdd/memoria/constitucion.md
+```
+
+## PASO 2 — Extraer todos los CAs
+
+Lee la spec y genera una lista de TODOS los criterios de aceptación con sus IDs:
+
+```
+CA-001-01: [texto del CA]
+CA-001-02: [texto del CA]
+...
+```
+
+## PASO 3 — Verificar CA por CA
+
+Para CADA CA, sigue este proceso:
+
+### 3.1 — Identificar dónde buscar
+Determina en qué parte del código debería estar implementado este CA:
+- Servicios/módulos relevantes
+- Tests que deberían cubrirlo
+
+### 3.2 — Buscar implementación
+```bash
+# Usa grep/glob para localizar código relacionado al CA
+grep -rn "[concepto del CA]" --include="*.ts" --include="*.py" --include="*.js" .
+```
+
+### 3.3 — Buscar test
+```bash
+# Hay test que verifica este CA específicamente?
+grep -rn "[CA-001-01 o el comportamiento]" --include="*test*" --include="*spec*" .
+```
+
+### 3.4 — Verificar manualmente
+Lee el código encontrado. ¿Realmente implementa lo que pide el CA?
+
+- ✅ **Implementado y testeado**
+- ⚠️ **Implementado pero sin test específico**
+- ⚠️ **Implementado parcialmente** (cubre algunos escenarios pero no todos)
+- ❌ **No implementado**
+
+## PASO 4 — Verificar requisitos funcionales
+
+Repite el proceso para cada RF-XXX de la spec.
+
+## PASO 5 — Verificar requisitos no funcionales
+
+Estos requieren validación específica:
+
+- **Rendimiento**: ¿hay benchmark? ¿la métrica se cumple?
+- **Seguridad**: ¿se aplicaron las medidas? Invocar agente `seguridad`
+- **Accesibilidad**: ¿se respetan los estándares? (revisar UI si aplica)
+- **Disponibilidad**: ¿el manejo de errores/retries existe?
+
+## PASO 6 — Verificar exclusiones
+
+Las "Exclusiones Explícitas" de la spec dicen qué NO debía implementarse. Verifica:
+- ¿Se respetaron? (no se agregó funcionalidad fuera de scope)
+
+## PASO 7 — Verificar cumplimiento de constitución
+
+Para CADA principio de la constitución:
+- ¿El código respeta el principio?
+- Si no, ¿hay justificación documentada en "Complejidad Justificada" del plan?
+
+## PASO 8 — Correr tests completos
+
+```bash
+# Detectar y ejecutar la suite completa
+[ -f package.json ] && (npm test || pnpm test || yarn test) 2>&1
+[ -f pyproject.toml ] && (pytest -v || python -m pytest -v) 2>&1
+[ -f Cargo.toml ] && cargo test 2>&1
+[ -f go.mod ] && go test ./... 2>&1
+```
+
+## PASO 9 — Verificar tareas como completas
+
+Lee `.estado-tareas.json` y verifica:
+- ¿Las tareas marcadas como `completada` tienen sus archivos modificados?
+- ¿Hay tareas `bloqueada` que necesitan resolución?
+
+## PASO 10 — Generar reporte de verificación
+
+Crea `.sdd/especificaciones/{ID}/verificacion.md`:
+
+```markdown
+---
+spec_id: {SPEC_ID}
+fecha_verificacion: {FECHA}
+veredicto: APROBADA | APROBADA_CON_OBSERVACIONES | RECHAZADA
+---
+
+# Verificación Final: {SPEC_ID}
+
+## Veredicto: **{VEREDICTO}**
+
+[Resumen ejecutivo]
+
+## Cumplimiento de Criterios de Aceptación
+
+| CA | Descripción | Implementado | Testeado | Archivo(s) | Test(s) |
+|----|-------------|--------------|----------|-----------|---------|
+| CA-001-01 | [texto] | ✅ | ✅ | src/auth.ts:45 | tests/auth.test.ts:12 |
+| CA-001-02 | [texto] | ⚠️ Parcial | ❌ | src/auth.ts:78 | — |
+| CA-002-01 | [texto] | ❌ | — | — | — |
+
+## Cumplimiento de Requisitos Funcionales
+
+| RF | Cumple | Notas |
+|----|--------|-------|
+| RF-001 | ✅ | — |
+| RF-002 | ⚠️ | [explicación] |
+
+## Cumplimiento de Requisitos No Funcionales
+
+| RNF | Métrica | Esperado | Medido | Cumple |
+|-----|---------|---------|--------|--------|
+| Rendimiento | latencia p95 | <200ms | 180ms | ✅ |
+| Seguridad | auth requerida | sí | sí | ✅ |
+
+## Exclusiones Respetadas
+
+| Exclusión | Respetada |
+|-----------|-----------|
+| [exclusión 1] | ✅ |
+
+## Cumplimiento de Constitución
+
+| Principio | Cumple |
+|-----------|--------|
+| Principio I | ✅ |
+| Principio II | ⚠️ — ver Complejidad Justificada del plan |
+
+## Suite de Tests
+
+- Framework: [detectado]
+- Tests totales: [N]
+- Pasados: [N]
+- Fallidos: [N]
+- Cobertura: [%]
+- Umbral mínimo (constitución): [%]
+- **Cumple**: ✅/❌
+
+## Hallazgos
+
+### 🔴 Críticos (bloquean entrega)
+[Lista]
+
+### 🟡 Importantes (corregir antes de release)
+[Lista]
+
+### 🟢 Menores (mejoras futuras)
+[Lista]
+
+## Recomendaciones
+
+[Lista accionable]
+
+## Sugerencia de siguiente acción
+
+[Comando o acción manual]
+```
+
+## PASO 11 — Determinar veredicto
+
+**APROBADA**: 
+- 100% CAs cubiertos e implementados
+- Todos los RF cumplidos
+- Tests pasando
+- Cobertura sobre el umbral
+- Constitución respetada
+
+**APROBADA_CON_OBSERVACIONES**:
+- ≥95% CAs cubiertos
+- Hallazgos menores
+- Tests pasando
+
+**RECHAZADA**:
+- CAs sin implementar
+- Tests fallando
+- Violaciones graves de constitución
+
+## PASO 12 — Acción
+
+**APROBADA:**
+```
+✅ Verificación: APROBADA
+🎉 La implementación cumple TODOS los criterios
+
+📁 .sdd/especificaciones/{ID}/verificacion.md
+
+SIGUIENTES PASOS:
+   /sdd.snapshot       — actualizar SNAPSHOT.md del producto
+   (haz commit y push manualmente)
+```
+
+**APROBADA_CON_OBSERVACIONES:**
+```
+🟡 Verificación: APROBADA CON OBSERVACIONES
+✅ Cumple los CAs críticos
+⚠️  [N] observaciones documentadas
+
+Puedes entregar, pero considera abordar las observaciones.
+```
+
+**RECHAZADA:**
+```
+❌ Verificación: RECHAZADA
+🔴 [N] CAs no cumplidos
+
+ACCIONES REQUERIDAS:
+[Lista priorizada]
+
+Vuelve a:
+   /sdd.implementar    — completar tareas pendientes
+```

package/configuracion-ejemplo/hooks-ejemplo/antes_cada_tarea.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# antes_cada_tarea.sh — se ejecuta antes de cada tarea individual en /sdd.implementar
+# Cópialo a .sdd/hooks/ y hazlo ejecutable: chmod +x .sdd/hooks/antes_cada_tarea.sh
+#
+# Recibe como argumento: $1 = TAREA_ID (ej: "T003")
+# El agente puede pasar variables de entorno opcionales:
+#   SDD_ARCHIVOS  — archivos que la tarea va a modificar
+#   SDD_COMANDO   — comando que la tarea va a ejecutar (si aplica)
+
+TAREA_ID="${1:-?}"
+export SDD_TAREA_ID="$TAREA_ID"
+
+echo "🔒 Verificación de seguridad para ${TAREA_ID}..."
+
+# Invocar el guardia para esta tarea específica
+bash "$(dirname "$0")/guardia-seguridad.sh"
+
+echo "✅ ${TAREA_ID} — verificaciones pasadas, iniciando ejecución"

package/configuracion-ejemplo/hooks-ejemplo/antes_implementar.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# antes_implementar.sh — se ejecuta antes de cada /sdd.implementar
+# Cópialo a .sdd/hooks/ y hazlo ejecutable: chmod +x .sdd/hooks/antes_implementar.sh
+
+set -euo pipefail
+
+# ── 1. Guardia de seguridad ──────────────────────────────────
+# Bloquea .env, comandos destructivos, push sin confirmación, secrets hardcodeados
+bash "$(dirname "$0")/guardia-seguridad.sh"
+
+# ── 2. Verificar rama git ────────────────────────────────────
+# (Ya cubierto por guardia-seguridad.sh — esto es redundante si usas el guardia)
+
+# ── 3. Verificar tests previos pasan ────────────────────────
+# No implementes sobre una base rota
+echo "🔍 Verificando que los tests actuales pasan antes de implementar..."
+
+TESTS_OK=false
+
+if [ -f package.json ]; then
+  npx jest --passWithNoTests --silent 2>/dev/null && TESTS_OK=true \
+  || pnpm test --silent 2>/dev/null && TESTS_OK=true \
+  || TESTS_OK=false
+fi
+
+if [ -f pyproject.toml ] || [ -f pytest.ini ]; then
+  python -m pytest -q --tb=no 2>/dev/null && TESTS_OK=true || TESTS_OK=false
+fi
+
+if [ -f Cargo.toml ]; then
+  cargo test -q 2>/dev/null && TESTS_OK=true || TESTS_OK=false
+fi
+
+if [ "$TESTS_OK" = "false" ]; then
+  echo "⚠️  Los tests actuales tienen fallos pre-existentes."
+  echo "   Implementar sobre una base rota dificulta identificar regresiones."
+  echo "   ¿Continuar de todos modos? (s/N)"
+  read -r RESP
+  if [ "$RESP" != "s" ] && [ "$RESP" != "S" ]; then
+    echo "❌ Implementación cancelada — corrige los tests fallidos primero."
+    exit 1
+  fi
+fi
+
+echo "✅ Hook antes_implementar completado"

package/configuracion-ejemplo/hooks-ejemplo/despues_especificar.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Ejemplo: crear branch Git automáticamente al crear una spec
+
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json | cut -d'"' -f4)
+
+if [ -d .git ] && [ -n "$SPEC_ID" ]; then
+  RAMA="spec/${SPEC_ID}"
+  
+  # Solo crear si no existe
+  if ! git show-ref --verify --quiet "refs/heads/${RAMA}"; then
+    git checkout -b "$RAMA" 2>/dev/null && \
+      echo "✅ Branch creada: $RAMA"
+  fi
+fi

package/configuracion-ejemplo/hooks-ejemplo/despues_implementar.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Ejemplo: aplicar linter después de implementar
+# Cópialo a .sdd/hooks/ y hazlo ejecutable
+
+if [ -f package.json ]; then
+  echo "🧹 Aplicando linter..."
+  npm run lint --fix 2>/dev/null || pnpm lint --fix 2>/dev/null || yarn lint --fix 2>/dev/null
+fi
+
+if [ -f pyproject.toml ]; then
+  echo "🧹 Aplicando formateador..."
+  ruff format . 2>/dev/null || black . 2>/dev/null
+fi
+
+if [ -f Cargo.toml ]; then
+  echo "🧹 Aplicando rustfmt..."
+  cargo fmt 2>/dev/null
+fi
+
+echo "✅ Hook despues_implementar completado"
+
+# ===== NUEVO: Actualizar mapas =====
+if [ -d ".sdd/mapa" ]; then
+  echo "🗺️  Actualizando mapas..."
+  bash ./.claude/bin/mapear.sh validar > /dev/null 2>&1 || true
+  
+  # Obtener archivos modificados en esta sesión
+  # (esto es aproximado, en producción usarías git diff)
+  MAPA_ANTIGUO=$(stat -c %Y .sdd/mapa/estructura.md 2>/dev/null || echo 0)
+  ARCHIVOS_NUEVOS=$(find . -newer <(date -r $MAPA_ANTIGUO) -type f 2>/dev/null | grep -v '.sdd' | wc -l)
+  
+  if [ "$ARCHIVOS_NUEVOS" -gt 0 ]; then
+    echo "📝 Detectados $ARCHIVOS_NUEVOS archivos modificados"
+    echo "⏰ Próxima actualización: /sdd.mapear actualizar"
+  fi
+fi

package/configuracion-ejemplo/hooks-ejemplo/despues_planificar.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# Ejemplo: notificación a Slack/Teams cuando un plan se aprueba
+
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json | cut -d'"' -f4)
+TITULO=$(grep "^titulo:" ".sdd/especificaciones/${SPEC_ID}/spec.md" | cut -d'"' -f2)
+
+if [ -n "$SLACK_WEBHOOK" ]; then
+  curl -s -X POST "$SLACK_WEBHOOK" \
+    -H 'Content-type: application/json' \
+    --data "{\"text\":\"📋 Plan SDD aprobado: ${TITULO} (${SPEC_ID})\"}"
+  echo "✅ Notificación enviada a Slack"
+fi
+
+if [ -n "$TEAMS_WEBHOOK" ]; then
+  curl -s -X POST "$TEAMS_WEBHOOK" \
+    -H 'Content-type: application/json' \
+    --data "{\"text\":\"📋 Plan SDD aprobado: ${TITULO} (${SPEC_ID})\"}"
+  echo "✅ Notificación enviada a Teams"
+fi