sdd-es 2.0.0 → 2.6.0

package/commands/sdd.interpretar.md

@@ -0,0 +1,239 @@
+---
+description: Punto de entrada de FORGE. Convierte una idea en texto libre a un IR JSON validado. Orquesta discovery + interpreter + validación. Primer comando para cualquier proyecto nuevo.
+allowed-tools: Read, Write, Bash
+---
+
+# /sdd.interpretar — Entrada a FORGE
+
+**Uso:**
+```
+/sdd.interpretar [idea en texto libre]
+```
+
+**Ejemplos:**
+```
+/sdd.interpretar Quiero una app para que mis clientes reserven citas
+/sdd.interpretar Necesito algo para organizar los pedidos de mi restaurante
+/sdd.interpretar Plataforma de cursos online con pagos y certificados
+/sdd.interpretar confirmar
+/sdd.interpretar corregir "es para múltiples negocios, no solo uno"
+```
+
+---
+
+## PASO 1 — Detectar modo de invocación
+
+```bash
+ARGS="$*"
+```
+
+Detecta el caso:
+
+| Argumento | Modo |
+|-----------|------|
+| `confirmar` o `sí` | Confirmar IR pendiente → guardar |
+| `corregir [qué]` | Corregir campo del IR pendiente |
+| `ver` | Mostrar IR actual en `.sdd/ir.json` |
+| `[texto libre]` | Nueva idea → flujo completo |
+| *(vacío)* | Pedir que escriba su idea |
+
+---
+
+## PASO 2 — Si es texto libre: flujo completo
+
+### 2.1 — Verificar si hay IR anterior
+
+```bash
+if [ -f ".sdd/ir.json" ]; then
+  echo "HAY_IR_ANTERIOR"
+  cat .sdd/ir.json | grep '"name"' | head -1
+fi
+```
+
+Si hay IR anterior, pregunta:
+```
+Ya tienes un proyecto en curso: [product.name]
+
+¿Qué quieres hacer?
+  1) Continuar con ese proyecto → escribe /sdd.diseñar
+  2) Actualizar la idea de ese proyecto → escribe /sdd.interpretar corregir [qué]
+  3) Empezar un proyecto nuevo → escribe /sdd.interpretar nuevo [idea]
+```
+
+Si no hay IR anterior, continúa.
+
+### 2.2 — Crear carpeta .sdd/
+
+```bash
+mkdir -p .sdd
+```
+
+### 2.3 — Invocar skill `descubrir-idea`
+
+Activa la skill de discovery. La skill hace las 5 preguntas y guarda `.sdd/descubrimiento.md`.
+
+Después de que el usuario responda las 5 preguntas, continúa al paso 2.4.
+
+### 2.4 — Invocar skill `interpretar-idea`
+
+Activa la skill con la idea original del usuario + contexto de `.sdd/descubrimiento.md`.
+
+La skill genera el IR JSON en 2 fases (razonamiento libre + extracción JSON) y lo muestra al usuario.
+
+**Si la skill requiere clarificación** (`confidence < 0.7`): el usuario responde la pregunta, y la skill re-genera el IR. Luego continúa.
+
+---
+
+## PASO 3 — Si es `confirmar` o `sí`
+
+```bash
+# Verificar que hay un IR pendiente de confirmar
+if [ ! -f ".sdd/ir-pendiente.json" ] && [ ! -f ".sdd/ir.json" ]; then
+  echo "No hay ningún IR pendiente. Escribe tu idea primero:"
+  echo "  /sdd.interpretar [tu idea]"
+  exit 0
+fi
+```
+
+Guarda el IR:
+
+```bash
+cp .sdd/ir-pendiente.json .sdd/ir.json 2>/dev/null || true
+```
+
+Actualiza `.sdd/estado.json`:
+
+```bash
+# Leer estado actual o crear si no existe
+if [ -f ".sdd/estado.json" ]; then
+  # Agregar campo ir_generado: true
+  node -e "
+    const fs = require('fs');
+    const estado = JSON.parse(fs.readFileSync('.sdd/estado.json', 'utf8'));
+    estado.ir_generado = true;
+    estado.ir_id = JSON.parse(fs.readFileSync('.sdd/ir.json', 'utf8')).id;
+    estado.ultima_actualizacion = new Date().toISOString();
+    fs.writeFileSync('.sdd/estado.json', JSON.stringify(estado, null, 2));
+  " 2>/dev/null || echo "{ \"ir_generado\": true, \"ultima_actualizacion\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\" }" > .sdd/estado.json
+fi
+```
+
+Muestra confirmación y siguiente paso:
+
+```
+✅ IR guardado en .sdd/ir.json
+
+Siguiente paso → Diseño de pantallas y arquitectura:
+  /sdd.diseñar
+
+O si quieres ir directo al código (diseño automático):
+  /sdd.construir
+```
+
+---
+
+## PASO 4 — Si es `corregir [qué]`
+
+Extrae la corrección del argumento. Por ejemplo:
+- `/sdd.interpretar corregir "es para múltiples negocios"` → actualizar `product.target_users` y/o `assumptions`
+
+Lee el IR actual:
+
+```bash
+cat .sdd/ir.json 2>/dev/null || cat .sdd/ir-pendiente.json 2>/dev/null
+```
+
+Aplica la corrección al campo correspondiente del IR. Re-valida. Muestra el IR actualizado y pide confirmación de nuevo.
+
+---
+
+## PASO 5 — Si es `ver`
+
+```bash
+cat .sdd/ir.json 2>/dev/null || echo "No hay IR guardado todavía."
+```
+
+Muestra el IR en formato legible (igual que la skill `interpretar-idea`).
+
+---
+
+## PASO 6 — Si argumento vacío
+
+```
+¿Cuál es tu idea?
+
+Cuéntamela en una frase o párrafo. No te preocupes por el formato.
+
+Ejemplos:
+  /sdd.interpretar Quiero una app para gestionar turnos de mi peluquería
+  /sdd.interpretar Sistema para que mis empleados registren sus horas de trabajo
+  /sdd.interpretar Marketplace de servicios para freelancers
+```
+
+---
+
+## Estructura de archivos generados
+
+```
+.sdd/
+  descubrimiento.md      ← Respuestas del discovery (5 preguntas)
+  ir-analysis.md         ← Análisis libre de la Fase A del Interpreter
+  ir-pendiente.json      ← IR generado, esperando confirmación del usuario
+  ir.json                ← IR confirmado (se crea solo tras "confirmar")
+  estado.json            ← Estado global del proyecto (ir_generado: true)
+```
+
+---
+
+## Integración con el pipeline
+
+Después de `/sdd.interpretar confirmar`:
+
+```
+/sdd.diseñar     → Diseña pantallas, elige dirección visual, genera wireframe
+/sdd.construir   → Pipeline completo: diseño + spec + plan + tareas + código
+/sdd.estado      → Ver estado actual del proyecto
+```
+
+---
+
+## Opciones avanzadas
+
+### Modo silencioso (sin discovery)
+
+Si el usuario ya dio suficiente contexto en la idea:
+
+```
+/sdd.interpretar --rapido [idea detallada]
+```
+
+Salta el discovery y va directo al Interpreter.
+
+### Actualizar proyecto existente
+
+```
+/sdd.interpretar actualizar "quiero agregar pagos en línea"
+```
+
+1. Lee IR actual
+2. Interpreta el cambio
+3. Fusiona (agrega feature, actualiza assumptions)
+4. Re-valida y pide confirmación
+
+### Nuevo proyecto (ignorar IR anterior)
+
+```
+/sdd.interpretar nuevo [idea]
+```
+
+Archiva el IR anterior en `.sdd/ir-anterior-[timestamp].json` y empieza desde cero.
+
+---
+
+## Notas de implementación
+
+- Este comando es el **único punto de entrada** para usuarios no técnicos
+- El IR es la **fuente de verdad** del proyecto — todo lo demás se deriva de él
+- La skill `descubrir-idea` y la skill `interpretar-idea` son los módulos reales — este comando las orquesta
+- Si el usuario dice "sí" o "confirmar" en cualquier momento durante el flujo, se guarda el IR actual
+- El modelo **nunca inventa** datos del usuario — todo en `assumptions[]` debe ser explícito

package/commands/sdd.md

@@ -20,6 +20,38 @@ else
 fi
 ```
 
+**Recuperación de contexto automática:** Si existe `.sdd/estado.json`, antes de pedir nada al usuario muestra un resumen de **exactamente 3 líneas** con:
+
+1. `pipeline_step` actual (campo `pipeline_step` del estado).
+2. Spec activa (campo `spec_activa` o equivalente).
+3. Número de tareas pendientes.
+
+Ejemplo:
+
+```
+Paso del pipeline: implementar
+Spec activa: 2026-06-14-auth
+Tareas pendientes: 3
+```
+
+## PASO 1.2 — Detectar modo de output
+
+Si el argumento del comando contiene un modo de output (`pm`, `arq`, `dev`), actívalo globalmente para esta sesión:
+
+| Argumento | Modo | Descripción |
+|-----------|------|-------------|
+| `pm` o `producto` | **Product Manager** | Lenguaje de negocio, sin código, bullets ejecutivos. Oculta detalles técnicos. |
+| `arq` o `arquitectura` | **Arquitecto** | Diagramas, decisiones técnicas, trade-offs. Para revisiones de diseño. |
+| `dev` o `desarrollo` | **Desarrollador** | Código, diffs, comandos. Modo por defecto. |
+
+Ejemplos:
+- `/sdd.estado pm` → dashboard en lenguaje de negocio
+- `/sdd.verificar arq` → reporte técnico con diagramas
+- `/sdd.analizar dev` → análisis con código y rutas de archivo
+
+El modo se guarda en `MODO_OUTPUT` y lo usan todos los comandos que producen reportes.  
+Si no se especifica, usa `dev` (comportamiento actual).
+
 ## PASO 1.5 — Detectar el perfil y ajustar el modo de conducción
 
 Lee el perfil desde el estado o la configuración:
@@ -27,10 +59,11 @@ Lee el perfil desde el estado o la configuración:
 ```bash
 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:-experto}"
+# Por defecto: modo guiado (sin jerga) — si sdd.config.yaml declara explícitamente "perfil: experto", se respeta
+echo "PERFIL=${PERFIL:-guiado}"
 ```
 
-**Si `PERFIL=guiado`:** activa la skill `modo-guiado` y conduce TODO el resto de la interacción según sus 6 reglas (sin jerga, confirmar antes de actuar, una pregunta a la vez, nunca pedir que edite archivos). En este modo:
+**Si `PERFIL=guiado` (o no hay perfil configurado):** activa la skill `modo-guiado` y conduce TODO el resto de la interacción según sus 6 reglas (sin jerga, confirmar antes de actuar, una pregunta a la vez, nunca pedir que edite archivos). En este modo:
 
 - **Encadenas automáticamente** los pasos del flujo (especificar → planificar → tareas → implementar) pidiendo solo una confirmación simple entre fases, sin exponer los nombres de los comandos. El usuario dice "sí" y tú avanzas.
 - Traduces cada fase a lenguaje natural (ver tabla en la skill `modo-guiado`).
@@ -40,7 +73,7 @@ Ejemplo de conducción en modo guiado:
 
 > Entendido, quieres una lista de tareas. Primero voy a entender bien los detalles, luego lo construyo y lo pruebo. ¿Arrancamos? (responde *sí*)
 
-**Si `PERFIL=experto` (o no hay perfil):** sigue el enrutamiento normal del PASO 2, exponiendo comandos.
+**Si `PERFIL=experto`:** sigue el enrutamiento normal del PASO 2, exponiendo comandos técnicos. Este modo se activa SOLO cuando el archivo `sdd.config.yaml` incluye explícitamente `perfil: experto`.
 
 ## PASO 2 — Interpretar la intención del usuario
 
@@ -48,6 +81,11 @@ El usuario invocó este comando con argumentos en lenguaje natural. Mapea su int
 
 | Intención del usuario | Comando a ejecutar |
 |----------------------|--------------------|
+| "tengo una idea", "quiero crear", "quiero construir X desde cero", "dame una app de X" | `/sdd.interpretar [idea]` |
+| "interpreta mi idea", "analiza lo que quiero hacer" | `/sdd.interpretar` |
+| "diseña el producto", "elige el estilo", "quiero ver el wireframe" | `/sdd.diseñar` |
+| "construye todo", "haz el código completo", "pipeline completo" | `/sdd.construir` |
+| "exporta el bundle", "empaqueta el proyecto" | `/sdd.exportar` |
 | "quiero inicializar", "configurar el proyecto", "empezar" | `/sdd.constitucion` |
 | "quiero crear una feature", "nueva spec", "voy a hacer X" | `/sdd.especificar [resto]` |
 | "quiero importar una spec externa" | `/sdd.importar [resto]` |
@@ -69,15 +107,56 @@ El usuario invocó este comando con argumentos en lenguaje natural. Mapea su int
 | "cambia configuración", "ajusta agentes/modelos" | `/sdd.configurar` |
 | "indexa el proyecto", "genera mapa de símbolos" | `/sdd.mapear` |
 | "comprime", "ahorra tokens", "compacta memoria" | `/sdd.comprimir` |
+| "optimiza artefactos", "reduce contexto" | `/sdd.optimizar` |
+| "optimiza memoria", "compacta agente" | `/sdd.optimizar-memoria` |
+| "compliance", "reporte regulatorio", "GDPR", "SOC2" | `/sdd.compliance` |
+| "registra decisión", "ADR", "architecture decision" | `/sdd.adr` |
+| "reporte de bugs", "defect rate", "tasa de defectos" | `/sdd.defect-report` |
 | "haz un release", "nueva versión", "changelog" | `/sdd.release` |
 | "descubre el proyecto", "tengo una idea vaga" | `/sdd.descubrir` |
 | "crea una app", "construye una app", "quiero una app de X" | `/sdd.crear-app [resto]` |
 | "crea un MCP", "quiero una herramienta para Claude", "genera un servidor MCP" | `/sdd.crear-mcp [resto]` |
 | "ayuda", "qué puedes hacer" | `/sdd.ayuda` |
 
+## PASO 2.5 — Detectar IR sin spec activa (FORGE)
+
+Si hay `.sdd/ir.json` pero NO hay spec activa, sugiere el siguiente paso del pipeline de FORGE:
+
+```bash
+HAS_IR=$([ -f ".sdd/ir.json" ] && echo "yes" || echo "no")
+HAS_DESIGN=$([ -f ".sdd/product-design.json" ] && echo "yes" || echo "no")
+SPEC_ACTIVA=$(cat .sdd/estado.json 2>/dev/null | grep -o '"spec_activa": *"[^"]*"' | cut -d'"' -f4)
+```
+
+Si `HAS_IR=yes` y sin spec activa:
+
+> Ya tienes una idea interpretada: **[product.name]**.
+>
+> ¿Qué quieres hacer?
+> - `/sdd.diseñar` → elegir estilo visual y generar wireframe
+> - `/sdd.construir` → pipeline completo automático (diseño + código)
+> - `/sdd.exportar` → empaquetar lo que hay ahora
+
+---
+
 ## PASO 3 — Si no está inicializado
 
-Si el proyecto NO está inicializado, no importa qué pidió el usuario — responde:
+Si el proyecto NO está inicializado, primero verifica si la intención del usuario es FORGE (idea → MVP):
+
+```bash
+TIENE_IDEA=$(echo "$ARGS" | grep -iE "tengo una idea|quiero crear|quiero construir|quiero una app|necesito|idea" && echo "yes" || echo "no")
+TIENE_INTERPRETAR=$(echo "$ARGS" | grep -iE "interpreta|interpretar" && echo "yes" || echo "no")
+```
+
+**Si la intención es FORGE** (tiene idea, quiere crear algo desde cero):
+
+> 👋 Empecemos. No necesitas inicializar nada primero.
+>
+> Cuéntame tu idea y FORGE la convierte en un producto.
+
+Llama directamente a `/sdd.interpretar [idea del usuario]`. FORGE crea `.sdd/` automáticamente.
+
+**Si la intención NO es FORGE** (quiere usar sdd-lite para una feature de código existente):
 
 > 👋 Bienvenido a SDD-ES.
 >
@@ -87,6 +166,16 @@ Si el proyecto NO está inicializado, no importa qué pidió el usuario — resp
 
 Luego llama internamente a `/sdd.constitucion`.
 
+**Si no hay argumentos** (usuario escribió solo `/sdd` en proyecto no inicializado):
+
+> 👋 Bienvenido. ¿Qué quieres hacer?
+>
+> **Tengo una idea y quiero construirla**
+> → `/sdd.interpretar [tu idea]`
+>
+> **Tengo un proyecto de código y quiero especificar features**
+> → `/sdd.constitucion` (configura el proyecto primero)
+
 ## PASO 4 — Si ya está inicializado pero hay una spec activa incompleta
 
 Lee `estado.json` y `.estado-tareas.json` de la spec activa.

package/commands/sdd.optimizar-memoria.md

@@ -0,0 +1,47 @@
+---
+description: Comprimir manualmente la memoria de agentes (deduplicación + compresión)
+allowed-tools: Read, Write, Bash
+---
+
+# /sdd.optimizar memoria
+
+Comprime automáticamente los archivos de memoria de agentes (`.sdd/memoria/agente-*.md`) cuando superan 50KB.
+
+## Uso
+
+```
+/sdd.optimizar memoria
+```
+
+## Qué Hace
+
+1. **Lee** archivos en `.sdd/memoria/`
+2. **Deduplica** entradas por filepath (guarda solo la más reciente)
+3. **Comprime** aplicando diccionario Caveman Level Full
+4. **Crea backup** `.original.md` antes de sobrescribir
+5. **Reporta** bytes salvados
+
+## Ejemplo
+
+```
+ANTES: agente-arquitecto.md = 150KB (80 entradas)
+
+/sdd.optimizar memoria
+
+✨ [compress] arquitecto: 150KB → 15KB (10%), backup en .original.md
+✨ [compress] critico: 87KB → 8.7KB (10%)
+
+DESPUÉS: memoria total = 24KB
+```
+
+## Seguridad
+
+- Nunca pierdes datos (backup siempre)
+- Idempotente (ejecutar 2 veces = mismo resultado)
+- Reversible: `.original.md` contiene datos originales
+
+## Notas
+
+- Se ejecuta automáticamente vía hook cuando memoria > 50KB
+- Puedes ejecutarla manualmente cuando quieras
+- Segura para ejecutar frecuentemente (sin riesgos)

package/commands/sdd.optimizar.md

@@ -0,0 +1,164 @@
+---
+description: Ciclo completo de optimización de tokens para la sesión actual — detecta fan-out, recomienda modelos por fase, comprime memoria si supera umbral, audita oportunidades de caché y proyecta presupuesto. Punto de entrada unificado para uso eficiente de tokens en FORGE.
+allowed-tools: Read, Bash
+---
+
+# /sdd.optimizar — Optimización de Tokens
+
+## Subcomandos disponibles
+
+| Subcomando | Qué ejecuta |
+|---|---|
+| `/sdd.optimizar` | Ciclo completo (PASOes 1-6) |
+| `/sdd.optimizar tokens` | Solo effort-router + cache-audit |
+| `/sdd.optimizar memoria` | Solo memory-compactor |
+| `/sdd.optimizar presupuesto` | Solo token-budget |
+
+---
+
+## PASO 1 — Verificar que el proyecto está inicializado
+
+```bash
+[ ! -d .sdd ] && echo "NO_INICIALIZADO" && exit 0
+[ ! -f .sdd/estado.json ] && echo "SIN_ESTADO" && exit 0
+cat .sdd/estado.json
+```
+
+Si no está inicializado: mostrar `🚫 SDD-ES no inicializado. Ejecuta: /sdd.constitucion` y terminar.
+
+---
+
+## PASO 2 — Leer ledger de consumo (observabilidad)
+
+```bash
+if [ -f .sdd/observabilidad/consumo.jsonl ]; then
+  wc -l .sdd/observabilidad/consumo.jsonl
+  cat .sdd/observabilidad/consumo.jsonl
+else
+  echo "SIN_LEDGER"
+fi
+```
+
+Si `SIN_LEDGER`: marcar PASO 2 como "Sin datos de sesión — ledger vacío" y continuar.
+
+Si hay datos: invocar la skill `observabilidad-consumo` para obtener:
+- Tabla por agente (invocaciones, bytes, archivos únicos)
+- Alertas de fan-out (>5 agentes distintos, >20 invocaciones de un agente, >500KB total)
+
+---
+
+## PASO 3 — Routing de effort (si hay fase activa o alertas de fan-out)
+
+Invocar la skill `effort-router` con la fase del `estado.json`.
+
+Si el subcomando es `/sdd.optimizar presupuesto` o `/sdd.optimizar memoria`, saltar este paso.
+
+Mostrar la tabla de modelos recomendados y el ahorro estimado.
+
+---
+
+## PASO 4 — Comprimir memoria si supera umbral
+
+```bash
+# Verificar tamaño de archivos de memoria
+for f in .sdd/memoria/agente-*.md; do
+  [ -f "$f" ] || continue
+  entradas=$(grep -c "^## " "$f" 2>/dev/null || echo 0)
+  bytes=$(wc -c < "$f" 2>/dev/null || echo 0)
+  echo "MEMORIA:$f:$entradas:$bytes"
+done
+```
+
+Si algún archivo supera **80 entradas** o **50 000 bytes**: invocar la skill `memory-compactor`.
+
+Si el subcomando es `/sdd.optimizar tokens` o `/sdd.optimizar presupuesto`, saltar este paso.
+
+Si ningún archivo supera el umbral: marcar "✅ Memoria dentro del umbral".
+
+---
+
+## PASO 5 — Auditar oportunidades de caché
+
+```bash
+# Detectar agentes instalados en el proyecto
+ls .claude/agents/ 2>/dev/null || echo "SIN_AGENTES_LOCALES"
+
+# Detectar patterns que invalidan caché silenciosamente
+grep -rn "$(date +%Y-%m-%d)\|[0-9a-f]\{8\}-[0-9a-f]\{4\}\|consumo\.jsonl" .claude/agents/ 2>/dev/null || echo "SIN_INVALIDADORES"
+```
+
+Invocar la skill `cache-audit` con los resultados.
+
+Si el subcomando es `/sdd.optimizar memoria` o `/sdd.optimizar presupuesto`, saltar este paso.
+
+---
+
+## PASO 6 — Proyectar presupuesto de fases restantes
+
+```bash
+# Tareas pendientes de la spec activa
+SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json 2>/dev/null | cut -d'"' -f4)
+if [ -n "$SPEC_ID" ]; then
+  cat ".sdd/especificaciones/${SPEC_ID}/.estado-tareas.json" 2>/dev/null || echo "SIN_TAREAS"
+fi
+```
+
+Invocar la skill `token-budget` con el estado, tareas pendientes y datos del ledger.
+
+Si el subcomando es `/sdd.optimizar tokens` o `/sdd.optimizar memoria`, saltar este paso.
+
+---
+
+## PASO 7 — Reporte unificado
+
+Generar el reporte final ordenando las acciones por impacto decreciente:
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║            ⚡ SDD.OPTIMIZAR — Reporte de Eficiencia             ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Proyecto: {nombre}  |  Fase: {fase}  |  {fecha}                ║
+╠══════════════════════════════════════════════════════════════════╣
+║  📊 CONSUMO DE SESIÓN                                            ║
+║                                                                  ║
+║  {tabla por agente o "Sin datos de sesión"}                      ║
+║  {alertas de fan-out o "✅ Sin alertas"}                         ║
+╠══════════════════════════════════════════════════════════════════╣
+║  🎯 ROUTING DE MODELOS (fase: {fase})                            ║
+║                                                                  ║
+║  {tabla effort-router}                                           ║
+║  Ahorro estimado vs. Opus-en-todo: ~{%}%                         ║
+╠══════════════════════════════════════════════════════════════════╣
+║  🧠 MEMORIA DE AGENTES                                           ║
+║                                                                  ║
+║  {estado por agente: OK / comprimido / pendiente}                ║
+╠══════════════════════════════════════════════════════════════════╣
+║  🔄 CACHÉ                                                        ║
+║                                                                  ║
+║  {oportunidades detectadas o "✅ Sin invalidadores detectados"}  ║
+╠══════════════════════════════════════════════════════════════════╣
+║  💰 PRESUPUESTO DE FASES RESTANTES                               ║
+║                                                                  ║
+║  {tabla por fase: costo estimado y recomendación PTC}            ║
+╠══════════════════════════════════════════════════════════════════╣
+║  🚀 ACCIONES RECOMENDADAS (por impacto)                          ║
+║                                                                  ║
+║  1. {acción de mayor impacto con comando concreto}               ║
+║  2. {segunda acción}                                             ║
+║  3. {tercera acción}                                             ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+### Lógica de priorización de acciones
+
+Ordenar las recomendaciones así:
+1. **Fan-out activo** (>5 agentes o >20 invocaciones) → acción inmediata con `effort-router`
+2. **Memoria sobre umbral** (>50KB) → `memory-compactor`
+3. **Invalidadores de caché detectados** → `cache-audit` con fix sugerido
+4. **Fases costosas por delante** → `token-budget` + sugerencia de PTC
+
+Si no hay ninguna de estas condiciones:
+```
+✅ La sesión está optimizada. No se detectan acciones de alto impacto.
+   Próximo paso sugerido según fase: {COMANDO_SDD}
+```

package/commands/sdd.planificar.md

@@ -21,6 +21,8 @@ Eres el **Orquestador del Plan**. Coordinas a los agentes especializados configu
 
 **Si el usuario escribió `/sdd.planificar revisar`**: muestra el plan actual y pide cambios específicos.
 
+**Si el usuario escribió `/sdd.planificar cambios [descripción]`**: registra feedback específico, edita el plan, y regresa al PASO 9 (aprobación explícita).
+
 ## VERIFICACIONES PRE-EJECUCIÓN
 
 ```bash
@@ -296,6 +298,68 @@ EOF
 # Actualizar entrada de INDICE.md: "plan: ✅"
 ```
 
+## PASO 8 — Presentar el plan (resumen ejecutivo)
+
+No muestres el plan técnico completo. En su lugar, presenta un **resumen ejecutivo** adaptado al perfil:
+
+**Si perfil == "guiado":**
+
+```
+✅ PLAN LISTO PARA CONSTRUIR
+
+Lo que voy a hacer:
+→ [3-5 frases en lenguaje simple de lo que se construye]
+
+Tecnología que usaré:
+→ [stack elegido, explicado sin jerga. Ej: "JavaScript (lenguaje web), SQLite (base de datos simple y gratis), Node.js (servidor web)"]
+
+Tiempo aproximado:
+→ [estimación legible: "unos 30-45 minutos"]
+
+Archivos que cambiarán:
+→ [lista simple de carpetas/conceptos afectados, no rutas técnicas]
+
+Lo que queda por hacer después:
+→ [QA, deploy, etc.]
+```
+
+**Si perfil == "experto":**
+
+Muestra el plan técnico completo (todas las 17 secciones) con decisiones, riesgos y justificaciones.
+
+## PASO 9 — Solicitar aprobación EXPLÍCITA
+
+**Gate humano:** No avances a tareas sin aprobación clara.
+
+```
+¿Está bien este plan?
+
+Responde:
+  ✅ "sí" → Avanzamos con /sdd.tareas
+  🔄 "cambio [descripción]" → Edito el plan y pregunto de nuevo
+  ❌ "rechazar" → Abortamos y revisamos la especificación
+```
+
+Si usuario responde "cambio X":
+1. Edita solo la sección relevante del plan
+2. Vuelve al PASO 8 (resumen ejecutivo)
+3. Solicita aprobación explícita nuevamente
+
+**Guardar aprobación:**
+
+```bash
+# Si aprobación == "sí"
+cat >> .sdd/estado.json << 'EOF'
+"plan_aprobado": true,
+"plan_aprobacion_timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+"plan_aprobacion_usuario": "usuario",
+EOF
+
+# Mensaje de confirmación
+echo "✅ Plan aprobado. Siguiente: /sdd.tareas"
+echo "💾 Tu aprobación se guardó automáticamente."
+```
+
 ## PASO 8 — Pedir aprobación del plan
 
 Si `comportamiento.requerir_aprobacion_plan: true` en config: